diff --git a/.ci/community-jenkins/Jenkinsfile b/.ci/community-jenkins/Jenkinsfile
index 2c20d630ac1..603b3a379db 100644
--- a/.ci/community-jenkins/Jenkinsfile
+++ b/.ci/community-jenkins/Jenkinsfile
@@ -59,21 +59,28 @@ def prepare_check_stages() {
 	"--disable-dlopen",
 	"--disable-oshmem",
 	"--enable-builtin-atomic",
-	"--enable-ipv6"
+	"--enable-ipv6",
+	"--enable-mca-dso"
     ]
+    // explicitly list the newest and oldest versions of GCC that are included
+    // in the distros listed below to try and give us good version coverage.
     def compilers = [
-	"gcc14",
-	"clang18"
+	"gcc9",
+	"gcc15",
+	"clang11",
+	"clang21"
     ]
     def platforms = [
-	"amazon_linux_2",
-	"amazon_linux_2-arm64",
 	"rhel8",
+	"rhel9",
+	"rhel10",
 	"amazon_linux_2023-arm64",
 	"amazon_linux_2023-x86_64",
-	"ubuntu_20.04",
+	"freebsd_15",
 	"ubuntu_24.04-arm64",
-	"ubuntu_24.04-x86_64"
+	"ubuntu_24.04-x86_64",
+	"ubuntu_26.04-arm64",
+	"ubuntu_26.04-x86_64"
     ]
     def check_stages_list = []
 
diff --git a/.ci/community-jenkins/pr-builder.sh b/.ci/community-jenkins/pr-builder.sh
index 88426859bf0..badd4cf670a 100755
--- a/.ci/community-jenkins/pr-builder.sh
+++ b/.ci/community-jenkins/pr-builder.sh
@@ -3,6 +3,7 @@
 # Copyright (c) 2022-2023 Amazon.com, Inc. or its affiliates.  All rights
 #                         reserved.
 # Copyright (c) 2022-2023 Joe Downs.  All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -17,7 +18,7 @@ COMPILER=
 DISTCHECK=0
 AUTOGEN_ARGS=
 CONFIGURE_ARGS=
-MAKE_ARGS=
+MAKE_ARGS="VERBOSE=1"
 MAKE_J="-j 8"
 PREFIX="${WORKSPACE}/install"
 MPIRUN_MODE=${MPIRUN_MODE:-runall}
@@ -145,13 +146,16 @@ if test "${COMPILER}" != "" ; then
         exit 1
     fi
 
+    set +u
     . ${HOME}/ompi-compiler-setup.sh
     activate_compiler ${COMPILER}
+    set -u
 
-    CONFIGURE_ARGS="${CONFIGURE_ARGS} CC=${CC} CPP=${CPP} CXX=${CXX} FC=${FC}"
-    if test "$FC" = "" ; then
+    CONFIGURE_ARGS="${CONFIGURE_ARGS} CC=${CC} CPP=${CPP} CXX=${CXX}"
+    if [ -z "${FC:-}" ] ; then
         CONFIGURE_ARGS="${CONFIGURE_ARGS} --disable-mpi-fortran"
     else
+        CONFIGURE_ARGS="${CONFIGURE_ARGS} FC=${FC}"
         # Flang doesn't seem good enough (yet) to compile our Fortran bindings,
         # so skip for now.
         case "${COMPILER}" in
@@ -164,6 +168,12 @@ fi
 
 CONFIGURE_ARGS="$CONFIGURE_ARGS --disable-silent-rules"
 
+# Work around the fact that FreeBSD's hwloc package installs Ze and
+# that breaks something in the cudasm path on FreeBSD.
+if test "${PLATFORM_ID}" = "FreeBSD" ; then
+    CONFIGURE_ARGS="${CONFIGURE_ARGS} --without-ze"
+fi
+
 echo "--> Compiler setup: $CONFIGURE_ARGS"
 
 #
@@ -241,10 +251,13 @@ fi
 
 echo "--> running make ${MAKE_J} ${MAKE_ARGS} all"
 make ${MAKE_J} ${MAKE_ARGS} all
-echo "--> running make check"
-make ${MAKE_ARGS} check
+# while backwards, it is important to run "make install" before "make check",
+# because many of the tests call opal_init(), which will fail unless it can find
+# components.
 echo "--> running make install"
 make ${MAKE_ARGS} install
+echo "--> running make check"
+make ${MAKE_ARGS} check
 
 export PATH="${PREFIX}/bin":${PATH}
 
diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000000..b002ea3373b
--- /dev/null
+++ b/.github/CODE_OF_CONDUCT.md
@@ -0,0 +1,46 @@
+# Open MPI Community Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the Open MPI project or its community. Examples of representing the project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of the project may be further defined and clarified by Open MPI maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at maintainers@open-mpi.org. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml
new file mode 100644
index 00000000000..af9a473663f
--- /dev/null
+++ b/.github/codeql/codeql-config.yml
@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+# CodeQL configuration for Open MPI.  Push / PR scans load this file
+# locally from the checked-out branch.  The scheduled cross-branch scan
+# loads this same file from the default branch via CodeQL's remote
+# config-file syntax, so the release-branch scans do not require a local
+# copy of this file to already exist.
+
+name: "Open MPI CodeQL config"
+
+paths-ignore:
+  - '3rd-party'
+  - '**/test'
diff --git a/.github/workflows/backport-command.yaml b/.github/workflows/backport-command.yaml
new file mode 100644
index 00000000000..719c55d62ae
--- /dev/null
+++ b/.github/workflows/backport-command.yaml
@@ -0,0 +1,172 @@
+# Slash-command handler for /backport.
+#
+# Posting a comment on a merged PR with:
+#
+#   /backport v5.0.x v4.1.x
+#
+# is equivalent to manually triggering the "Backport" workflow from the
+# GitHub Actions UI with those branch names.  Multiple branches may be
+# supplied as space- or comma-separated values on the same line.
+#
+# Only repository owners, organisation members, and collaborators may trigger
+# the command.  If an unauthorised user attempts /backport, the bot replies
+# with an explanatory comment.  For valid commands it acknowledges with a 👀
+# reaction; invalid or unrecognised commands get a usage hint as a comment.
+
+name: Backport slash command
+
+on:
+    issue_comment:
+        types: [created]
+
+permissions: {}
+
+jobs:
+    dispatch:
+        name: Handle /backport comment
+        runs-on: ubuntu-latest
+        # Only act on PR comments (issue_comment fires for both issues and PRs).
+        if: github.event.issue.pull_request != null
+        permissions:
+            actions: write       # trigger workflow_dispatch
+            issues: write        # post comments
+        steps:
+            - name: Generate GitHub App token
+              id: app-token
+              uses: actions/create-github-app-token@v1
+              with:
+                  app-id: ${{ secrets.APP_ID }}
+                  private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+            - name: Parse command and validate PR
+              id: parse
+              uses: actions/github-script@v8
+              with:
+                  github-token: ${{ steps.app-token.outputs.token }}
+                  script: |
+                      const body        = context.payload.comment.body;
+                      const commentId   = context.payload.comment.id;
+                      const issueNumber = context.payload.issue.number;
+                      const login       = context.payload.comment.user.login;
+
+                      // Best-effort comment helper — if Issues are disabled on
+                      // the repo (common for forks) the call returns 403 and we
+                      // log a warning rather than aborting the workflow.
+                      async function tryComment(text) {
+                          try {
+                              await github.rest.issues.createComment({
+                                  owner:        context.repo.owner,
+                                  repo:         context.repo.repo,
+                                  issue_number: issueNumber,
+                                  body:         text,
+                              });
+                          } catch (err) {
+                              core.warning(`Could not post comment: ${err.message}`);
+                          }
+                      }
+
+                      // Detect a bare /backport with no arguments and reply helpfully.
+                      const bareMatch = /^\/backport\s*$/m.test(body);
+                      // Look for /backport with arguments at the start of any line.
+                      const match = body.match(/^\/backport\s+([^\r\n]+)/m);
+
+                      // If the comment doesn't contain any /backport command at all,
+                      // do nothing — no need to check permissions.
+                      if (!bareMatch && !match) {
+                          core.setOutput('triggered', 'false');
+                          return;
+                      }
+
+                      // Use author_association from the webhook payload — no extra
+                      // API call required. getCollaboratorPermissionLevel requires
+                      // org-level "Members" read permission, which is not available
+                      // to either GITHUB_TOKEN or a GitHub App without explicit
+                      // org-level permission grants.
+                      const assoc = context.payload.comment.author_association;
+                      if (!['OWNER', 'MEMBER', 'COLLABORATOR'].includes(assoc)) {
+                          await tryComment(`⚠️ @${login} Backports can only be triggered by repository owners, organization members, or collaborators.`);
+                          core.setOutput('triggered', 'false');
+                          return;
+                      }
+
+                      if (bareMatch && !match) {
+                          core.setOutput('triggered', 'false');
+                          await tryComment('⚠️ `/backport` requires at least one target branch, e.g. `/backport v5.0.x`.');
+                          return;
+                      }
+                      if (!match) {
+                          core.setOutput('triggered', 'false');
+                          return;
+                      }
+
+                      // Parse branch list (space- or comma-separated).
+                      const branches = match[1].trim().split(/[\s,]+/).filter(Boolean);
+                      if (branches.length === 0) {
+                          // e.g. "/backport ,,," — separators only, no real branch names
+                          core.setOutput('triggered', 'false');
+                          await tryComment('⚠️ `/backport` requires at least one target branch, e.g. `/backport v5.0.x`.');
+                          return;
+                      }
+
+                      // Validate branch names with the same allow-list used in
+                      // backport.yaml so the user gets immediate feedback rather
+                      // than a silent dispatch failure.
+                      const validBranchRe = /^[a-zA-Z0-9][a-zA-Z0-9._\-/]*$/;
+                      const invalidBranches = branches.filter(b => !validBranchRe.test(b));
+                      if (invalidBranches.length > 0) {
+                          core.setOutput('triggered', 'false');
+                          await tryComment(`⚠️ Invalid branch name(s): ${invalidBranches.map(b => `\`${b}\``).join(', ')}. Branch names may only contain alphanumeric characters, dots, hyphens, underscores, and slashes.`);
+                          return;
+                      }
+
+                      // Confirm the PR is actually merged.
+                      // merged_at is present in the issue_comment webhook payload
+                      // for PRs, so no extra API call is needed.
+                      if (!context.payload.issue.pull_request.merged_at) {
+                          await tryComment('⚠️ Cannot backport: this PR has not been merged yet.');
+                          core.setOutput('triggered', 'false');
+                          return;
+                      }
+
+                      // Acknowledge the command with a 👀 reaction on the triggering comment.
+                      // Ignore 422 (reaction already exists) so re-runs don't fail.
+                      try {
+                          await github.rest.reactions.createForIssueComment({
+                              owner:      context.repo.owner,
+                              repo:       context.repo.repo,
+                              comment_id: commentId,
+                              content:    'eyes',
+                          });
+                      } catch (err) {
+                          if (err.status !== 422) throw err;
+                      }
+
+                      core.setOutput('triggered', 'true');
+                      core.setOutput('pr_number', String(issueNumber));
+                      core.setOutput('branches',  branches.join(','));
+                      core.notice(`Dispatching backport of PR #${issueNumber} to: ${branches.join(', ')}`);
+
+            - name: Trigger backport workflow
+              if: steps.parse.outputs.triggered == 'true'
+              uses: actions/github-script@v8
+              env:
+                  PR_NUMBER: ${{ steps.parse.outputs.pr_number }}
+                  BRANCHES:  ${{ steps.parse.outputs.branches }}
+              with:
+                  script: |
+                      // workflow_dispatch requires a ref; use the default branch.
+                      const { data: repo } = await github.rest.repos.get({
+                          owner: context.repo.owner,
+                          repo:  context.repo.repo,
+                      });
+
+                      await github.rest.actions.createWorkflowDispatch({
+                          owner:       context.repo.owner,
+                          repo:        context.repo.repo,
+                          workflow_id: 'backport.yaml',
+                          ref:         repo.default_branch,
+                          inputs: {
+                              pr_number: process.env.PR_NUMBER,
+                              branches:  process.env.BRANCHES,
+                          },
+                      });
diff --git a/.github/workflows/backport.yaml b/.github/workflows/backport.yaml
new file mode 100644
index 00000000000..38fb7917d49
--- /dev/null
+++ b/.github/workflows/backport.yaml
@@ -0,0 +1,391 @@
+# Backport merged PRs to release branches.
+#
+# This workflow supports two modes:
+#
+# 1. Automatic (label-based): Apply one or more "backport:vX.Y.z" labels to a
+#    PR before merging.  Once the PR is merged, this workflow fires and creates
+#    a cherry-pick PR for each labelled target branch.
+#
+# 2. Manual (workflow_dispatch): After a PR has already been merged, trigger
+#    this workflow manually via the GitHub Actions UI, providing the PR number
+#    and a comma-separated list of target branches.
+#
+# For every successful cherry-pick, a new PR is opened against the target
+# branch and tagged with a "target:vX.Y.z" label.  If the cherry-pick
+# produces conflicts, a comment is posted on the original PR instead so a
+# developer can handle it manually.
+
+name: Backport
+
+on:
+    pull_request_target:
+        types: [closed]
+    workflow_dispatch:
+        inputs:
+            pr_number:
+                description: 'Number of the merged PR to backport'
+                required: true
+                type: number
+            branches:
+                description: 'Target release branches (comma-separated, e.g. v5.0.x,v4.1.x)'
+                required: true
+                type: string
+
+permissions: {}
+
+jobs:
+    # -------------------------------------------------------------------------
+    # Determine which branches need a backport and expose them as a matrix.
+    # -------------------------------------------------------------------------
+    prepare:
+        name: Prepare backport targets
+        runs-on: ubuntu-latest
+        # For pull_request_target: only act when the PR was actually merged AND
+        # carries at least one "backport:" label (avoids a spurious job run on
+        # every other merge).  For workflow_dispatch: always proceed.
+        if: >
+            github.event_name == 'workflow_dispatch' ||
+            (github.event.pull_request.merged == true &&
+             contains(toJson(github.event.pull_request.labels.*.name), '"backport:'))
+        outputs:
+            matrix: ${{ steps.targets.outputs.matrix }}
+            has_targets: ${{ steps.targets.outputs.has_targets }}
+            pr_number: ${{ steps.targets.outputs.pr_number }}
+        steps:
+            - name: Determine backport targets
+              id: targets
+              uses: actions/github-script@v8
+              with:
+                  script: |
+                      let branches = [];
+                      let prNumber;
+
+                      if (context.eventName === 'workflow_dispatch') {
+                          prNumber = Number(context.payload.inputs.pr_number);
+                          if (!Number.isFinite(prNumber) || prNumber <= 0 || !Number.isInteger(prNumber)) {
+                              core.setFailed(`Invalid pr_number: "${context.payload.inputs.pr_number}"`);
+                              return;
+                          }
+                          branches = context.payload.inputs.branches
+                              .split(',')
+                              .map(b => b.trim())
+                              .filter(Boolean);
+                      } else {
+                          prNumber = context.payload.pull_request.number;
+                          const labels = context.payload.pull_request.labels.map(l => l.name);
+                          for (const label of labels) {
+                              const match = label.match(/^backport:(.+)$/);
+                              if (match) {
+                                  branches.push(match[1].trim());
+                              }
+                          }
+                      }
+
+                      // Validate branch names with a strict allow-list: must start
+                      // with alphanumeric and contain only alphanumeric, dot,
+                      // hyphen, underscore, or slash.  De-duplicate preserving order.
+                      const validBranchRe = /^[a-zA-Z0-9][a-zA-Z0-9._\-/]*$/;
+                      const invalid = branches.filter(b => !validBranchRe.test(b));
+                      if (invalid.length > 0) {
+                          core.setFailed(`Invalid branch name(s): ${invalid.join(', ')}`);
+                          return;
+                      }
+                      branches = [...new Set(branches)];
+
+                      core.setOutput('pr_number', String(prNumber));
+                      core.setOutput('has_targets', branches.length > 0 ? 'true' : 'false');
+                      core.setOutput('matrix', JSON.stringify({ branch: branches }));
+
+                      if (branches.length === 0) {
+                          core.notice('No backport targets found — nothing to do.');
+                      } else {
+                          core.notice(`Will backport PR #${prNumber} to: ${branches.join(', ')}`);
+                      }
+
+    # -------------------------------------------------------------------------
+    # One job per target branch.  All branches run in parallel; a failure on
+    # one branch does not cancel the others.
+    # -------------------------------------------------------------------------
+    backport:
+        name: Backport to ${{ matrix.branch }}
+        needs: prepare
+        if: needs.prepare.outputs.has_targets == 'true'
+        runs-on: ubuntu-latest
+        permissions:
+            contents: write
+            pull-requests: write
+            issues: write
+        strategy:
+            matrix: ${{ fromJson(needs.prepare.outputs.matrix) }}
+            fail-fast: false
+        env:
+            PR_NUMBER: ${{ needs.prepare.outputs.pr_number }}
+            TARGET_BRANCH: ${{ matrix.branch }}
+        steps:
+            - name: Generate GitHub App token
+              id: app-token
+              uses: actions/create-github-app-token@v1
+              with:
+                  app-id: ${{ secrets.APP_ID }}
+                  private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+            - name: Checkout repository (full history)
+              uses: actions/checkout@v6
+              with:
+                  fetch-depth: 0
+                  token: ${{ steps.app-token.outputs.token }}
+
+            - name: Configure git identity
+              run: |
+                  git config user.name  "${{ steps.app-token.outputs.app-slug }}[bot]"
+                  git config user.email "${{ steps.app-token.outputs.app-slug }}[bot]@users.noreply.github.com"
+
+            # Retrieve PR metadata (title, body, commit list) via the API.
+            # Use paginate() so PRs with more than 100 commits are handled correctly.
+            - name: Fetch PR metadata
+              id: pr_meta
+              uses: actions/github-script@v8
+              with:
+                  github-token: ${{ steps.app-token.outputs.token }}
+                  script: |
+                      const pr = await github.rest.pulls.get({
+                          owner: context.repo.owner,
+                          repo:  context.repo.repo,
+                          pull_number: Number(process.env.PR_NUMBER),
+                      });
+                      core.setOutput('title', pr.data.title);
+                      // Body may be empty/null — default to empty string.
+                      core.setOutput('body',  pr.data.body ?? '');
+
+                      // Collect all commit SHAs in merge order, paginating as needed.
+                      const commits = await github.paginate(github.rest.pulls.listCommits, {
+                          owner:       context.repo.owner,
+                          repo:        context.repo.repo,
+                          pull_number: Number(process.env.PR_NUMBER),
+                          per_page:    100,
+                      });
+                      const shas = commits.map(c => c.sha);
+                      core.setOutput('commits', shas.join(' '));
+
+            # Verify the target release branch actually exists before doing any
+            # work.  Post a comment and skip if it does not.
+            - name: Validate target branch exists
+              id: validate
+              uses: actions/github-script@v8
+              with:
+                  github-token: ${{ steps.app-token.outputs.token }}
+                  script: |
+                      try {
+                          await github.rest.repos.getBranch({
+                              owner:  context.repo.owner,
+                              repo:   context.repo.repo,
+                              branch: process.env.TARGET_BRANCH,
+                          });
+                          core.setOutput('branch_exists', 'true');
+                      } catch (err) {
+                          if (err.status !== 404) throw err;
+                          await github.rest.issues.createComment({
+                              owner:        context.repo.owner,
+                              repo:         context.repo.repo,
+                              issue_number: Number(process.env.PR_NUMBER),
+                              body: `⚠️ Cannot backport to \`${process.env.TARGET_BRANCH}\`: branch does not exist in this repository.`,
+                          });
+                          core.setOutput('branch_exists', 'false');
+                      }
+
+            # Cherry-pick every commit from the PR onto a new branch based on
+            # the target release branch.  Push the branch on success; set a
+            # flag on conflict so the next step can report the failure.
+            - name: Cherry-pick commits onto backport branch
+              id: cherry_pick
+              if: steps.validate.outputs.branch_exists == 'true'
+              env:
+                  COMMITS: ${{ steps.pr_meta.outputs.commits }}
+              run: |
+                  set -euo pipefail
+
+                  # Resolve a unique branch name.  The counter handles the common
+                  # case of re-running a backport; the push-retry below handles the
+                  # rare race where two concurrent runs pick the same name.
+                  git fetch --prune origin
+                  # Fetch the PR's original commits so they are available locally
+                  # regardless of how the PR was merged (squash, rebase, merge commit).
+                  git fetch origin "refs/pull/${PR_NUMBER}/head"
+                  BASE_BRANCH="backport/pr-${PR_NUMBER}-to-${TARGET_BRANCH}"
+                  BACKPORT_BRANCH="${BASE_BRANCH}"
+                  counter=1
+                  while git ls-remote --exit-code --heads origin "${BACKPORT_BRANCH}" > /dev/null 2>&1; do
+                      counter=$((counter + 1))
+                      BACKPORT_BRANCH="${BASE_BRANCH}-${counter}"
+                  done
+                  echo "backport_branch=${BACKPORT_BRANCH}" >> "$GITHUB_OUTPUT"
+
+                  git fetch origin "${TARGET_BRANCH}"
+                  git checkout -b "${BACKPORT_BRANCH}" "origin/${TARGET_BRANCH}"
+
+                  cherry_pick_failed=false
+                  failed_sha=""
+                  for sha in $COMMITS; do
+                      echo "Cherry-picking ${sha} ..."
+
+                      # Detect merge commits (more than one parent) and cherry-pick
+                      # relative to the first parent with -m 1.
+                      parent_count=$(git cat-file -p "${sha}" | grep -c '^parent ' || true)
+                      if [ "${parent_count}" -gt 1 ]; then
+                          echo "  Merge commit detected, using -m 1"
+                          cherry_flags="-m 1"
+                      else
+                          cherry_flags=""
+                      fi
+
+                      # --empty=drop silently skips commits already applied to the
+                      # target branch rather than recording a no-op empty commit.
+                      if ! git cherry-pick --empty=drop -x ${cherry_flags} "${sha}"; then
+                          cherry_pick_failed=true
+                          failed_sha="${sha}"
+                          git cherry-pick --abort 2>/dev/null || true
+                          break
+                      fi
+                  done
+
+                  echo "cherry_pick_failed=${cherry_pick_failed}" >> "$GITHUB_OUTPUT"
+                  echo "failed_sha=${failed_sha}"               >> "$GITHUB_OUTPUT"
+
+                  if [ "${cherry_pick_failed}" = "false" ]; then
+                      # If every commit was already present in the target branch,
+                      # cherry-pick dropped them all and HEAD hasn't moved.
+                      new_commits=$(git rev-list --count "origin/${TARGET_BRANCH}..HEAD")
+                      if [ "${new_commits}" -eq 0 ]; then
+                          echo "nothing_to_backport=true" >> "$GITHUB_OUTPUT"
+                      else
+                          echo "nothing_to_backport=false" >> "$GITHUB_OUTPUT"
+                          # Push; on a naming collision from a concurrent run, fall back
+                          # to a name that includes the unique run ID.
+                          if ! git push origin "${BACKPORT_BRANCH}" 2>/dev/null; then
+                              BACKPORT_BRANCH="${BASE_BRANCH}-${GITHUB_RUN_ID}"
+                              git branch -m "${BACKPORT_BRANCH}"
+                              git push origin "${BACKPORT_BRANCH}"
+                              echo "backport_branch=${BACKPORT_BRANCH}" >> "$GITHUB_OUTPUT"
+                          fi
+                      fi
+                  fi
+
+            # All commits were already present in the target branch — no PR needed.
+            - name: Comment when nothing to backport
+              if: steps.cherry_pick.outputs.nothing_to_backport == 'true'
+              uses: actions/github-script@v8
+              with:
+                  github-token: ${{ steps.app-token.outputs.token }}
+                  script: |
+                      await github.rest.issues.createComment({
+                          owner:        context.repo.owner,
+                          repo:         context.repo.repo,
+                          issue_number: Number(process.env.PR_NUMBER),
+                          body: `ℹ️ All commits from this PR are already present in \`${process.env.TARGET_BRANCH}\` — no backport needed.`,
+                      });
+                      core.notice(`Nothing to backport to ${process.env.TARGET_BRANCH} — all commits already present.`);
+
+            # Open a PR against the target branch and attach the target:* label.
+            - name: Create backport PR
+              if: >-
+                  steps.cherry_pick.outputs.cherry_pick_failed == 'false' &&
+                  steps.cherry_pick.outputs.nothing_to_backport == 'false'
+              uses: actions/github-script@v8
+              env:
+                  ORIGINAL_TITLE: ${{ steps.pr_meta.outputs.title }}
+                  ORIGINAL_BODY:  ${{ steps.pr_meta.outputs.body }}
+                  BACKPORT_BRANCH: ${{ steps.cherry_pick.outputs.backport_branch }}
+              with:
+                  github-token: ${{ steps.app-token.outputs.token }}
+                  script: |
+                      const prNumber     = Number(process.env.PR_NUMBER);
+                      const targetBranch = process.env.TARGET_BRANCH;
+                      const labelName    = `target:${targetBranch}`;
+
+                      // Ensure the target:* label exists in this repo.
+                      try {
+                          await github.rest.issues.getLabel({
+                              owner: context.repo.owner,
+                              repo:  context.repo.repo,
+                              name:  labelName,
+                          });
+                      } catch (err) {
+                          if (err.status === 404) {
+                              try {
+                                  await github.rest.issues.createLabel({
+                                      owner: context.repo.owner,
+                                      repo:  context.repo.repo,
+                                      name:  labelName,
+                                      color: '0075ca',
+                                      description: `Backport targeting the ${targetBranch} branch`,
+                                  });
+                              } catch (createErr) {
+                                  // 422 = another concurrent job created the label first; safe to ignore.
+                                  if (createErr.status !== 422) throw createErr;
+                              }
+                          } else {
+                              throw err;
+                          }
+                      }
+
+                      const title = `[${targetBranch}] ${process.env.ORIGINAL_TITLE}`;
+                      const body  = [
+                          `Backport of #${prNumber} to \`${targetBranch}\`.`,
+                          '',
+                          '---',
+                          '',
+                          process.env.ORIGINAL_BODY,
+                      ].join('\n');
+
+                      const { data: newPR } = await github.rest.pulls.create({
+                          owner: context.repo.owner,
+                          repo:  context.repo.repo,
+                          title,
+                          body,
+                          head:  process.env.BACKPORT_BRANCH,
+                          base:  targetBranch,
+                      });
+
+                      await github.rest.issues.addLabels({
+                          owner:        context.repo.owner,
+                          repo:         context.repo.repo,
+                          issue_number: newPR.number,
+                          labels:       [labelName],
+                      });
+
+                      core.notice(`Opened backport PR #${newPR.number}: ${newPR.html_url}`);
+
+            # If cherry-pick failed, leave a comment on the original PR so a
+            # developer knows to create the backport manually.
+            - name: Comment on cherry-pick failure
+              if: steps.cherry_pick.outputs.cherry_pick_failed == 'true'
+              uses: actions/github-script@v8
+              env:
+                  FAILED_SHA: ${{ steps.cherry_pick.outputs.failed_sha }}
+              with:
+                  github-token: ${{ steps.app-token.outputs.token }}
+                  script: |
+                      const prNumber     = Number(process.env.PR_NUMBER);
+                      const targetBranch = process.env.TARGET_BRANCH;
+                      const failedSha    = process.env.FAILED_SHA;
+
+                      await github.rest.issues.createComment({
+                          owner:        context.repo.owner,
+                          repo:         context.repo.repo,
+                          issue_number: prNumber,
+                          body: [
+                              `⚠️ **Automatic backport to \`${targetBranch}\` failed.**`,
+                              '',
+                              `Cherry-pick of commit ${failedSha} produced conflicts.`,
+                              'Please create the backport manually:',
+                              '',
+                              '```bash',
+                              `git fetch origin ${targetBranch}`,
+                              `git checkout -b backport/pr-${prNumber}-to-${targetBranch} origin/${targetBranch}`,
+                              `git cherry-pick -x <commits>`,
+                              `git push origin backport/pr-${prNumber}-to-${targetBranch}`,
+                              '```',
+                          ].join('\n'),
+                      });
+
+                      core.warning(`Cherry-pick to ${targetBranch} failed at ${failedSha} — manual backport required.`);
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 00000000000..d6b7a123565
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,409 @@
+#
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+# CodeQL (GitHub code scanning / static analysis) configuration for
+# Open MPI.
+#
+# What this workflow does:
+#
+#   1. Runs CodeQL analysis on every pull request and on every push
+#      (i.e., merge) to main and the supported release branches.  This
+#      catches newly-introduced problems at the moment code changes.
+#
+#   2. Runs a periodic (weekly, Monday morning UTC) CodeQL scan of main
+#      *and* the active release branches.
+#
+# Why run periodic scans in addition to the per-PR / per-merge scans?
+#
+#   The PR/merge scans only ever examine code at the moment it changes.
+#   But CodeQL's query packs and analysis engine are continually
+#   updated as new classes of vulnerabilities (and new CVEs) are
+#   discovered.  The weekly scan re-analyzes the *existing* code base
+#   with the latest queries, so a vulnerability pattern that was
+#   unknown when a piece of code was merged can still be found later --
+#   even though that code has not changed and therefore would never be
+#   re-examined by a push/PR scan.  Release branches in particular tend
+#   to go quiet between point releases, so the periodic scan is often
+#   the only thing that keeps their results current.
+#
+# A note on branches and where this file must live:
+#
+#   - push and pull_request workflows always run from the copy of this
+#     file on the branch receiving the push / targeted by the PR (not
+#     from main).  So to get PR and merge analysis on a release branch
+#     (e.g., v5.0.x, v6.0.x), this file must also be committed on that
+#     branch.
+#
+#   - The schedule (cron) event is special: it only ever fires from the
+#     default branch (main).  To periodically scan the release branches
+#     as well, the scheduled job below explicitly checks out each
+#     branch and tells the analyze action which ref/sha to attribute
+#     the results to.  The scheduled job is therefore inert on the
+#     release branches (it never fires there); only the copy on main
+#     drives the weekly scans.
+#
+# Why mostly inline (and not a composite action or reusable workflow):
+# the two jobs below intentionally duplicate the init / build / analyze
+# steps.
+# Because per-branch CI requires this file to be cherry-picked onto each
+# release branch anyway, keeping the workflow logic here is simpler than
+# factoring the shared steps out. Sharing them would not buy a
+# cross-branch single source of truth, and local workflow/action paths
+# would actually break the weekly scan, since they resolve from the
+# checked-out branch rather than from main. The CodeQL config sidecar is
+# the exception: the scheduled job uses CodeQL's remote config-file
+# syntax to load the sidecar file from main, so the config stays
+# single-sourced while the analyzed worktree is a release branch.
+#
+# We started running CodeQL on the main, v5.0.x, and v6.0.x branches in
+# June 2026.  Subsequent release branches are matched by the branch
+# globs below (for PR/merge scans) and should be added to the scheduled
+# job's branch list on main (for the weekly scans).
+
+name: "CodeQL Advanced"
+
+on:
+  push:
+    # Defined once here (&scan_branches) and reused by pull_request
+    # below via a YAML alias, so the two trigger lists cannot drift.
+    branches: &scan_branches
+      - main
+      - 'v[5-9].*.x'       # Matches v5.0.x through v9.9.x
+      - 'v[1-9][0-9]+.*.x' # Matches v10.0.x and higher (double digits+)
+  pull_request:
+    branches: *scan_branches
+  schedule:
+    # Monday morning (UTC).  The off-the-hour minute avoids GitHub's
+    # top-of-the-hour scheduling congestion.
+    - cron: '32 5 * * 1'
+  workflow_dispatch:
+
+permissions:
+  # required for all workflows
+  security-events: write
+  # required to fetch internal or private CodeQL packs
+  packages: read
+  # only required for workflows in private repositories
+  actions: read
+  contents: read
+
+# Cancel a superseded in-progress run when a newer commit is pushed to
+# the same pull request, to avoid stacking up expensive C/C++ builds.
+# The group includes the event name so push/schedule runs live in
+# separate groups, and cancellation is enabled only for pull_request
+# runs -- never the weekly scheduled scan or pushes to a branch.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  # -------------------------------------------------------------------
+  # Event-driven analysis: scans the ref that triggered the push / PR.
+  # -------------------------------------------------------------------
+  analyze:
+    if: >-
+      github.event_name != 'schedule' &&
+      github.event_name != 'workflow_dispatch' &&
+      github.repository == 'open-mpi/ompi'
+    name: Analyze ${{ matrix.language }} (${{ github.ref_name }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: actions
+            build-mode: none
+          - language: c-cpp
+            build-mode: manual
+          - language: python
+            build-mode: none
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          submodules: recursive
+          persist-credentials: false
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v4
+        with:
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+          config-file: ./.github/codeql/codeql-config.yml
+
+      - name: Run manual build steps
+        if: matrix.build-mode == 'manual'
+        shell: bash
+        run: |
+          export AUTOMAKE_JOBS=$(nproc)
+          ./autogen.pl
+          ./configure
+          make -j $(nproc)
+
+      - name: Perform CodeQL Analysis
+        if: matrix.language != 'c-cpp'
+        uses: github/codeql-action/analyze@v4
+        with:
+          category: "/language:${{ matrix.language }}"
+
+      # CodeQL's paths-ignore setting does not filter C/C++ code that is
+      # compiled by a manual build.  Open MPI's normal build compiles
+      # bundled third-party projects, which gives CodeQL complete build
+      # context but can also produce alerts in code we do not maintain.
+      # For C/C++ only, write SARIF locally, remove alerts whose primary
+      # locations are under 3rd-party/, and then upload the filtered SARIF.
+      - name: Perform CodeQL Analysis
+        if: matrix.language == 'c-cpp'
+        uses: github/codeql-action/analyze@v4
+        with:
+          category: "/language:${{ matrix.language }}"
+          output: c-cpp-sarif-results
+          upload: failure-only
+
+      - name: Locate C/C++ SARIF
+        if: matrix.language == 'c-cpp'
+        id: cpp_sarif
+        shell: bash
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          sarif_files=(c-cpp-sarif-results/*.sarif)
+          if test ${#sarif_files[@]} -ne 1; then
+              echo "::error::Expected one C/C++ SARIF file, found ${#sarif_files[@]}"
+              exit 1
+          fi
+          echo "file=${sarif_files[0]}" >> "$GITHUB_OUTPUT"
+
+      - name: Filter third-party C/C++ SARIF results
+        if: matrix.language == 'c-cpp'
+        uses: advanced-security/filter-sarif@v1
+        with:
+          patterns: |
+            -3rd-party/**
+            -**/3rd-party/**
+          input: ${{ steps.cpp_sarif.outputs.file }}
+          output: ${{ steps.cpp_sarif.outputs.file }}
+
+      - name: Upload filtered C/C++ SARIF
+        if: matrix.language == 'c-cpp'
+        uses: github/codeql-action/upload-sarif@v4
+        with:
+          sarif_file: ${{ steps.cpp_sarif.outputs.file }}
+          category: "/language:${{ matrix.language }}"
+
+  # -------------------------------------------------------------------
+  # Scheduled/manual analysis: explicitly scans main and each release
+  # branch. The schedule only fires from the default branch (main); see
+  # the header comment. workflow_dispatch intentionally runs this same
+  # matrix so the scheduled path can be tested without waiting for the
+  # next cron event.
+  # -------------------------------------------------------------------
+  analyze-scheduled:
+    if: >-
+      (github.event_name == 'schedule' ||
+       github.event_name == 'workflow_dispatch') &&
+      github.repository == 'open-mpi/ompi'
+    name: Analyze ${{ matrix.language }} (${{ matrix.branch }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        # Concrete branch names only: this matrix drives
+        # 'actions/checkout', so (unlike the on.push.branches globs)
+        # these cannot be globs or regexes. New release branches must be
+        # added here, too; the check-scheduled-coverage job enforces it.
+        branch:
+          - main
+          - v5.0.x
+          - v6.0.x
+        language:
+          - actions
+          - c-cpp
+          - python
+        include:
+          - language: actions
+            build-mode: none
+          - language: c-cpp
+            build-mode: manual
+          - language: python
+            build-mode: none
+    steps:
+      - name: Checkout ${{ matrix.branch }}
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ matrix.branch }}
+          submodules: recursive
+          persist-credentials: false
+
+      - name: Resolve commit SHA
+        id: commit
+        shell: bash
+        run: echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v4
+        with:
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+          config-file: >-
+            ${{ github.repository }}/.github/codeql/codeql-config.yml@${{ github.event.repository.default_branch }}
+
+      - name: Run manual build steps
+        if: matrix.build-mode == 'manual'
+        shell: bash
+        run: |
+          export AUTOMAKE_JOBS=$(nproc)
+          ./autogen.pl
+          ./configure
+          make -j $(nproc)
+
+      - name: Perform CodeQL Analysis
+        if: matrix.language != 'c-cpp'
+        uses: github/codeql-action/analyze@v4
+        with:
+          category: "/language:${{ matrix.language }}"
+          # Attribute results to the checked-out branch rather than to
+          # main (which is what a schedule event would otherwise report
+          # against).  The category is keyed on language only -- NOT on
+          # branch -- so each branch's results update in place and the
+          # weekly main scan stays consistent with its push/PR scans.
+          ref: refs/heads/${{ matrix.branch }}
+          sha: ${{ steps.commit.outputs.sha }}
+
+      # CodeQL's paths-ignore setting does not filter C/C++ code that is
+      # compiled by a manual build.  Open MPI's normal build compiles
+      # bundled third-party projects, which gives CodeQL complete build
+      # context but can also produce alerts in code we do not maintain.
+      # For C/C++ only, write SARIF locally, remove alerts whose primary
+      # locations are under 3rd-party/, and then upload the filtered SARIF.
+      - name: Perform CodeQL Analysis
+        if: matrix.language == 'c-cpp'
+        uses: github/codeql-action/analyze@v4
+        with:
+          category: "/language:${{ matrix.language }}"
+          output: c-cpp-sarif-results
+          upload: failure-only
+          # Attribute results to the checked-out branch rather than to
+          # main (which is what a schedule event would otherwise report
+          # against).  The category is keyed on language only -- NOT on
+          # branch -- so each branch's results update in place and the
+          # weekly main scan stays consistent with its push/PR scans.
+          ref: refs/heads/${{ matrix.branch }}
+          sha: ${{ steps.commit.outputs.sha }}
+
+      - name: Locate C/C++ SARIF
+        if: matrix.language == 'c-cpp'
+        id: cpp_sarif
+        shell: bash
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          sarif_files=(c-cpp-sarif-results/*.sarif)
+          if test ${#sarif_files[@]} -ne 1; then
+              echo "::error::Expected one C/C++ SARIF file, found ${#sarif_files[@]}"
+              exit 1
+          fi
+          echo "file=${sarif_files[0]}" >> "$GITHUB_OUTPUT"
+
+      - name: Filter third-party C/C++ SARIF results
+        if: matrix.language == 'c-cpp'
+        uses: advanced-security/filter-sarif@v1
+        with:
+          patterns: |
+            -3rd-party/**
+            -**/3rd-party/**
+          input: ${{ steps.cpp_sarif.outputs.file }}
+          output: ${{ steps.cpp_sarif.outputs.file }}
+
+      - name: Upload filtered C/C++ SARIF
+        if: matrix.language == 'c-cpp'
+        uses: github/codeql-action/upload-sarif@v4
+        with:
+          sarif_file: ${{ steps.cpp_sarif.outputs.file }}
+          category: "/language:${{ matrix.language }}"
+          # Match the scheduled analyze attribution above when uploading
+          # the filtered SARIF.
+          ref: refs/heads/${{ matrix.branch }}
+          sha: ${{ steps.commit.outputs.sha }}
+
+  # -------------------------------------------------------------------
+  # Guard: fail if a release branch that the push/pull_request globs
+  # cover is missing from the analyze-scheduled 'branch:' list, so new
+  # release branches don't silently drop out of the weekly scan.
+  #
+  # Runs only in the default-branch (main) context, where the scheduled
+  # matrix is authoritative. On a release branch the matrix is inert
+  # (the schedule fires only from the default branch) and its copy can
+  # lag main's, so running there would block CI for drift it can't fix.
+  # -------------------------------------------------------------------
+  check-scheduled-coverage:
+    if: >-
+      github.event_name == 'push' &&
+      github.ref_name == github.event.repository.default_branch &&
+      github.repository == 'open-mpi/ompi'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Verify periodic-scan branch coverage
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+
+          # The push/PR trigger globs in on.push.branches (above) are the
+          # single definition of which branches get scanned. This guard
+          # reads them from this file and converts each GitHub filter-glob
+          # to a regex (. -> \., * -> .*; +, ?, and [..] mean the same in
+          # both), so it matches exactly what the triggers match -- there
+          # is no second copy of the pattern to keep in sync. It then
+          # checks that every such branch is also listed in the
+          # analyze-scheduled matrix. python3 is always present on the
+          # runner, so (unlike yq) a runner image change cannot break it.
+          gh api --paginate "repos/${{ github.repository }}/branches" \
+            -q '.[].name' > "$RUNNER_TEMP/branches.txt"
+
+          python3 - .github/workflows/codeql.yml "$RUNNER_TEMP/branches.txt" <<'PY'
+          import sys, re
+
+          wf = open(sys.argv[1]).read()
+          branches = [b.strip() for b in open(sys.argv[2]) if b.strip()]
+
+          # on.push.branches globs -> anchored ERE regexes. Capture the
+          # whole push block (tolerates comments and the &scan_branches
+          # anchor on the branches: line) and pull out its list items.
+          push = re.search(r"(?ms)^  push:\n(.*?)^  \S", wf)
+          raw = re.findall(r"(?m)^      - (\S.*?) *(?:#.*)?$", push.group(1)) if push else []
+          globs = [x.strip().strip("'") for x in raw]
+          triggers = [re.compile("^" + g.replace(".", r"\.").replace("*", ".*") + "$")
+                      for g in globs]
+          if not triggers:
+              sys.exit("::error::could not parse on.push.branches; "
+                       "coverage guard cannot run")
+
+          # analyze-scheduled matrix branch list.
+          sched = re.search(r"(?ms)^        branch:\n(.*?)^        \S", wf)
+          scheduled = set(re.findall(r"^          - (\S+)", sched.group(1), re.M)) if sched else set()
+
+          missing = [b for b in branches
+                     if any(rx.match(b) for rx in triggers) and b not in scheduled]
+
+          if missing:
+              print("::error::Branch(es) get push/PR CodeQL scans but are missing "
+                    "from the weekly scan list: " + " ".join(missing))
+              print("Add them to jobs.analyze-scheduled.strategy.matrix.branch "
+                    "in .github/workflows/codeql.yml.")
+              sys.exit(1)
+          print("OK: every push/PR-scanned branch is covered by the weekly scan.")
+          PY
diff --git a/.github/workflows/compile-cuda.yaml b/.github/workflows/compile-cuda.yaml
index 9ba44b4c2b9..44d726cf9cd 100644
--- a/.github/workflows/compile-cuda.yaml
+++ b/.github/workflows/compile-cuda.yaml
@@ -21,11 +21,12 @@ jobs:
         sudo dpkg -i cuda-keyring_1.1-1_all.deb
         sudo apt update
         sudo apt install -y cuda-toolkit
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
             submodules: recursive
     - name: Build Open MPI
       run: |
+        export AUTOMAKE_JOBS=$(nproc)
         ./autogen.pl
         ./configure --prefix=${PWD}/install --with-cuda=${CUDA_PATH} --with-cuda-libdir=${CUDA_PATH}/lib64/stubs --disable-silent-rules
         make -j
diff --git a/.github/workflows/compile-examples.yaml b/.github/workflows/compile-examples.yaml
deleted file mode 100644
index aab1ed6e5ef..00000000000
--- a/.github/workflows/compile-examples.yaml
+++ /dev/null
@@ -1,22 +0,0 @@
-name: Compile ignored components
-
-on: [pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  compile-ignored:
-    runs-on: ubuntu-24.04
-    steps:
-    - uses: actions/checkout@v4
-      with:
-            submodules: recursive
-    - name: Remove .opal_ignore files so that we build all examples
-      run: |
-        find . -name .opal_ignore -exec rm -f {} \; -print
-    - name: Build Open MPI
-      run: |
-        ./autogen.pl
-        ./configure --prefix=${PWD}/install --disable-silent-rules
-        make -j
diff --git a/.github/workflows/compile-rocm.yaml b/.github/workflows/compile-rocm.yaml
index 804f2e4ce48..fad4956bdad 100644
--- a/.github/workflows/compile-rocm.yaml
+++ b/.github/workflows/compile-rocm.yaml
@@ -19,11 +19,12 @@ jobs:
         wget https://repo.radeon.com/amdgpu-install/7.2/ubuntu/jammy/amdgpu-install_7.2.70200-1_all.deb
         sudo apt install -y ./amdgpu-install_7.2.70200-1_all.deb
         sudo amdgpu-install --usecase=rocmdev
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
             submodules: recursive
     - name: Build Open MPI
       run: |
+        export AUTOMAKE_JOBS=$(nproc)
         ./autogen.pl
         ./configure --prefix=${PWD}/install --with-rocm=/opt/rocm --disable-mpi-fortran --disable-silent-rules
         LD_LIBRARY_PATH=/opt/rocm/lib make -j
diff --git a/.github/workflows/compile-ze.yaml b/.github/workflows/compile-ze.yaml
index b8fb08097e9..bc6760e941e 100644
--- a/.github/workflows/compile-ze.yaml
+++ b/.github/workflows/compile-ze.yaml
@@ -23,11 +23,12 @@ jobs:
         cd build
         cmake ../ -DCMAKE_INSTALL_PREFIX=/opt/ze
         sudo make -j1 install
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
             submodules: recursive
     - name: Build Open MPI (VPATH)
       run: |
+        export AUTOMAKE_JOBS=$(nproc)
         ./autogen.pl
         mkdir build
         cd build
diff --git a/.github/workflows/hdf5-tests.yaml b/.github/workflows/hdf5-tests.yaml
index 5dc7e88cd4c..4ff6c543107 100644
--- a/.github/workflows/hdf5-tests.yaml
+++ b/.github/workflows/hdf5-tests.yaml
@@ -13,11 +13,12 @@ jobs:
       run: |
         sudo apt update
         sudo apt install -y --no-install-recommends wget
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
             submodules: recursive
     - name: Build Open MPI
       run: |
+        export AUTOMAKE_JOBS=$(nproc)
         ./autogen.pl
         ./configure --prefix=/opt/openmpi --with-pmix=internal --with-prrte=internal --with-hwloc=internal --with-libevent=internal --disable-mpi-fortran --disable-oshmem
         make -j 8 && make install
diff --git a/.github/workflows/macos-checks.yaml b/.github/workflows/macos-checks.yaml
deleted file mode 100644
index 8b18c95e4ca..00000000000
--- a/.github/workflows/macos-checks.yaml
+++ /dev/null
@@ -1,49 +0,0 @@
-name: macOS
-
-on: [pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  macOS:
-    runs-on: macos-latest
-    steps:
-    - name: Setup macOS
-      run: |
-        # Copied from mpi4py/mpi-publish
-        # create gfortran symlink
-        cd $(brew --prefix)/bin
-        gfortran=$(ls gfortran-* | sort | head -n 1)
-        sudo ln -s $gfortran gfortran
-        # install autotools
-        brew install autoconf
-        brew install automake
-        brew install libtool
-        # unlink libevent
-        brew unlink libevent || true
-    - uses: actions/checkout@v4
-      with:
-            submodules: recursive
-    - name: Build Open MPI
-      run: |
-        ./autogen.pl
-        ./configure --prefix=/opt/openmpi --disable-silent-rules
-        make -j $(sysctl -n hw.logicalcpu)
-    - name: Run unit tests
-      run: |
-        make check
-    - name: Install Open MPI
-      run: |
-        sudo make install
-    - name: Add Open MPI to PATH
-      run: echo /opt/openmpi/bin >> $GITHUB_PATH
-    - name: Build examples
-      run: |
-        pushd examples
-        make
-        popd
-    - name: Test ring and sessions sanity check
-      run: |
-        mpirun --map-by ppr:1:core examples/ring_c
-        mpirun --map-by ppr:1:core examples/hello_sessions_c
diff --git a/.github/workflows/ompi-pr-builds.yaml b/.github/workflows/ompi-pr-builds.yaml
new file mode 100644
index 00000000000..354a4a49c04
--- /dev/null
+++ b/.github/workflows/ompi-pr-builds.yaml
@@ -0,0 +1,116 @@
+name: Build everything, make check, and run examples (Linux and macOS)
+
+# Build and test Open MPI on both Linux and macOS:
+#
+#   * Remove all .opal_ignore files so that even the normally-skipped
+#     components are compiled.
+#   * Force the Sphinx docs and the Fortran bindings to be built
+#     (--enable-sphinx / --enable-mpi-fortran), installing the Python
+#     packages Sphinx needs.
+#   * Build, then "make check" (intentionally before "make install"),
+#     then install.
+#   * Build and run all of the examples in the examples/ directory.
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  ompi-pr-builds:
+    strategy:
+      # Run both platforms to completion even if one fails.
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v6
+      with:
+        submodules: recursive
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3
+
+    - name: Install Python packages (Sphinx and friends)
+      run: python -m pip install --upgrade pip -r docs/requirements.txt
+
+    - name: Set up macOS build dependencies
+      if: runner.os == 'macOS'
+      run: |
+        # Create a plain "gfortran" symlink (Homebrew installs it as
+        # gfortran-NN).
+        cd $(brew --prefix)/bin
+        gfortran=$(ls gfortran-* | sort | head -n 1)
+        sudo ln -s $gfortran gfortran
+        # Autotools
+        brew install autoconf automake libtool
+        # Keep Homebrew's libevent from being picked up by configure
+        brew unlink libevent || true
+
+    - name: Set up Linux build dependencies
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y --no-install-recommends \
+            autoconf automake libtool flex gfortran
+
+    - name: Remove .opal_ignore files so that we build all components
+      run: |
+        find . -name .opal_ignore -exec rm -f {} \; -print
+
+    - name: Build Open MPI (forcing Sphinx docs and Fortran bindings)
+      run: |
+        NCPU=$(nproc 2>/dev/null || sysctl -n hw.logicalcpu)
+        # Parallelize automake's Makefile.in generation during autogen.pl.
+        export AUTOMAKE_JOBS=$NCPU
+        ./autogen.pl
+        ./configure --prefix=${PWD}/install \
+            --enable-sphinx \
+            --enable-mpi-fortran \
+            --disable-silent-rules
+        make -j $NCPU
+
+    - name: Run unit tests
+      # Deliberately run "make check" BEFORE "make install".
+      # VERBOSE=1 causes logs to be cat'ed if a test fails.
+      run: make check VERBOSE=1
+
+    - name: Install Open MPI
+      run: make install
+
+    - name: Add Open MPI to PATH
+      run: echo "${PWD}/install/bin" >> "$GITHUB_PATH"
+
+    - name: Build all examples
+      run: |
+        cd examples
+        make
+
+    - name: Run all built examples
+      run: |
+        cd examples
+        status=0
+        # Run every example binary that was actually built.  Built
+        # binaries are regular, executable, and have no filename
+        # extension (this skips sources, Makefiles, and macOS .dSYM
+        # bundles).  OpenSHMEM examples are launched with oshrun; all
+        # others with mpirun.
+        for exe in *; do
+          [ -f "$exe" ] && [ -x "$exe" ] || continue
+          case "$exe" in *.*) continue ;; esac
+          case "$exe" in
+            *oshmem*|oshmem_*) launcher=oshrun ;;
+            *)                 launcher=mpirun ;;
+          esac
+          echo "==== Running $exe (via $launcher) ===="
+          if ! "$launcher" --map-by ppr:1:core "./$exe"; then
+            echo "==== $exe FAILED"
+            status=1
+          fi
+        done
+        exit $status
diff --git a/.github/workflows/ompi_mpi4py.yaml b/.github/workflows/ompi_mpi4py.yaml
index 29abbcaf70d..c341b9fc00b 100644
--- a/.github/workflows/ompi_mpi4py.yaml
+++ b/.github/workflows/ompi_mpi4py.yaml
@@ -35,13 +35,13 @@ jobs:
       if:   ${{ runner.os == 'Linux' }}
 
     - name: Checkout Open MPI
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
        path: mpi-build
        submodules: recursive
 
     - name: Bootstrap Open MPI
-      run:  ./autogen.pl
+      run:  AUTOMAKE_JOBS=$(nproc) ./autogen.pl
       working-directory: mpi-build
 
     # Install into a separate directory (/opt/openmpi) so that we can
@@ -105,7 +105,7 @@ jobs:
               numpy cffi pyyaml
 
     - name: Checkout mpi4py
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         repository: ${{ inputs.repository || 'mpi4py/mpi4py' }}
         ref: ${{ inputs.ref }}
diff --git a/.github/workflows/ompi_mpi4py_asan.yaml b/.github/workflows/ompi_mpi4py_asan.yaml
index 240e3d2f101..ad5b89bf098 100644
--- a/.github/workflows/ompi_mpi4py_asan.yaml
+++ b/.github/workflows/ompi_mpi4py_asan.yaml
@@ -42,13 +42,13 @@ jobs:
       if:   ${{ runner.os == 'Linux' }}
 
     - name: Checkout Open MPI
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
        path: mpi-build
        submodules: recursive
 
     - name: Bootstrap Open MPI
-      run:  ./autogen.pl
+      run:  AUTOMAKE_JOBS=$(nproc) ./autogen.pl
       working-directory: mpi-build
 
     # Install into a separate directory (/opt/openmpi) so that we can
@@ -106,7 +106,7 @@ jobs:
               numpy cffi pyyaml
 
     - name: Checkout mpi4py
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         repository: ${{ inputs.repository || 'mpi4py/mpi4py' }}
         ref: ${{ inputs.ref }}
diff --git a/.github/workflows/ompi_nvidia.yaml b/.github/workflows/ompi_nvidia.yaml
index 8d550fad6cd..b587ea56562 100644
--- a/.github/workflows/ompi_nvidia.yaml
+++ b/.github/workflows/ompi_nvidia.yaml
@@ -14,11 +14,11 @@ jobs:
     runs-on: [self-hosted, linux, x64, nvidia]
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         submodules: recursive
     - name: Checkout CI scripts
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
         repository: Mellanox/jenkins_scripts
         path: ompi_ci
diff --git a/.github/workflows/riscv64-qemu-test.yaml b/.github/workflows/riscv64-qemu-test.yaml
index 56a6c741704..a36b4ad08c3 100644
--- a/.github/workflows/riscv64-qemu-test.yaml
+++ b/.github/workflows/riscv64-qemu-test.yaml
@@ -20,12 +20,13 @@ jobs:
         sed -i "s|libdir='/mnt/riscv/riscv64-unknown-linux-gnu/lib'|libdir='/opt/riscv/riscv64-unknown-linux-gnu/lib'|g" /opt/riscv/riscv64-unknown-linux-gnu/lib/libatomic.la
 
     - name: Checkout Open MPI
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
       with:
        submodules: recursive
     
     - name: Bootstrap Open MPI
       run: |
+        export AUTOMAKE_JOBS=$(nproc)
         ./autogen.pl
         sed -i '/^func_exec_program_core ()/,/^}/ s/\<exec\>/exec qemu-riscv64 -cpu rv64,v=true,vext_spec=v1.0,vlen=128 -L \/opt\/riscv\/sysroot/g' config/ltmain.sh
 
@@ -65,6 +66,6 @@ jobs:
         export QEMU_LD_PREFIX=/opt/riscv/sysroot
         export PATH="/opt/riscv/bin:$PATH"
         export LD_LIBRARY_PATH="/opt/riscv/lib:$LD_LIBRARY_PATH"
-        cd test/datatype
+        cd ompi/test/datatype
         qemu-riscv64 -cpu rv64,v=true,vext_spec=v1.0,vlen=128 /opt/riscv/bin/ompi_info --param all all --level 9 | grep "MCA op "
         qemu-riscv64 -cpu rv64,v=true,vext_spec=v1.0,vlen=128 /opt/riscv/bin/mpirun -n 1 ./reduce_local -l 1024 -u 1024
diff --git a/.gitignore b/.gitignore
index b30321da7ca..86ab1392aec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -228,13 +228,65 @@ ompi/mpi/fortran/use-mpi-tkr/mpi_kinds.ompi_module
 ompi/mpi/fortran/use-mpi-tkr/mpi-tkr-sizeof.f90
 ompi/mpi/fortran/use-mpi-tkr/mpi-tkr-sizeof.h
 
-ompi/mpi/java/java/mpi
-ompi/mpi/java/java/*.jar
-ompi/mpi/java/java/*.h
-ompi/mpi/java/java/doc
-
 ompi/mpi/tool/profile/*.c
 
+ompi/test/t/mpi_t_category_get_events
+
+ompi/test/file/file_info_defaults
+ompi/test/file/file_info_hints
+ompi/test/file/file_info_memkind
+ompi/test/file/file_info_set_view
+
+ompi/test/datatype/checksum
+ompi/test/datatype/ddt_pack
+ompi/test/datatype/ddt_raw
+ompi/test/datatype/ddt_raw2
+ompi/test/datatype/ddt_test
+ompi/test/datatype/external32
+ompi/test/datatype/large_data
+ompi/test/datatype/mpi_datatype_bigcount
+ompi/test/datatype/ompi_datatype_bigcount
+ompi/test/datatype/partial
+ompi/test/datatype/position
+ompi/test/datatype/position_noncontig
+ompi/test/datatype/reduce_local
+ompi/test/datatype/to_self
+ompi/test/datatype/unpack_ooo
+
+ompi/test/general/attr_interlang_mpifh
+ompi/test/general/attr_interlang_mpifh.f90
+ompi/test/general/attr_interlang_usempi
+ompi/test/general/attr_interlang_usempi.f90
+ompi/test/general/attr_interlang_usempif08
+ompi/test/general/attr_interlang_usempif08.f90
+ompi/test/general/attribute
+ompi/test/general/communicator
+ompi/test/general/datatype
+ompi/test/general/errhandler
+ompi/test/general/file
+ompi/test/general/group
+ompi/test/general/info_mpi
+ompi/test/general/info_t
+ompi/test/general/instance
+ompi/test/general/message
+ompi/test/general/mpi_init
+ompi/test/general/op
+ompi/test/general/ompi_file_test.dat
+ompi/test/general/proc
+ompi/test/general/request
+ompi/test/general/seq_tracker
+ompi/test/general/win
+ompi/test/general/win_notify
+ompi/test/general/win_notify_unsupported
+
+ompi/test/monitoring/monitoring_test
+ompi/test/monitoring/check_monitoring
+ompi/test/monitoring/example_reduce_count
+ompi/test/monitoring/test_overhead
+ompi/test/monitoring/test_pvar_access
+
+ompi/test/spc/spc_test
+
 ompi/mpiext/affinity/c/example
 
 ompi/mpiext/ftmpi/c/profile/pcomm_agree.c
@@ -277,7 +329,6 @@ ompi/tools/wrappers/ompi.pc
 ompi/tools/wrappers/ompi-c.pc
 ompi/tools/wrappers/ompi-cxx.pc
 ompi/tools/wrappers/ompi-fort.pc
-ompi/tools/wrappers/mpijavac.pl
 ompi/tools/wrappers/mpicxx-wrapper-data.txt
 ompi/tools/wrappers/mpif77-wrapper-data.txt
 ompi/tools/wrappers/mpif90-wrapper-data.txt
@@ -317,15 +368,13 @@ opal/tools/wrappers/opal.pc
 opal/util/show_help_content.c
 opal/util/keyval/keyval_lex.c
 
-test/monitoring/aggregate_profile.pl
-test/monitoring/profile2mat.pl
-
 test/simple/abort
 test/simple/accept
 test/simple/attach
 test/simple/bad_exit
 test/simple/bcast_loop
 test/simple/binding
+test/simple/comm_abort
 test/simple/concurrent_spawn
 test/simple/connect
 test/simple/crisscross
@@ -336,6 +385,7 @@ test/simple/hello_output
 test/simple/hello_show_help
 test/simple/hello
 test/simple/hello++
+test/simple/initial_errh
 test/simple/intercomm1
 test/simple/interlib
 test/simple/loop_child
@@ -344,6 +394,7 @@ test/simple/mpi_barrier
 test/simple/mpi_no_op
 test/simple/mpi_spin
 test/simple/multi_abort
+test/simple/ompio_file_info
 test/simple/parallel_r8
 test/simple/parallel_r64
 test/simple/parallel_w8
@@ -436,7 +487,7 @@ test/class/*.txt
 test/class/ompi_bitmap_test_out.txt
 test/class/ompi_circular_buffer_fifo
 test/class/ompi_fifo
-test/class/ompi_rb_tree
+test/class/opal_rb_tree
 test/class/ompi_bitmap
 test/class/opal_bitmap
 test/class/opal_fifo
@@ -448,30 +499,21 @@ test/class/opal_pointer_array
 test/class/opal_proc_table
 test/class/opal_tree
 test/class/opal_value_array
+test/class/opal_graph
+test/class/opal_hotel
+test/class/opal_interval_tree
+test/class/opal_ring_buffer
 
-test/datatype/ddt_test
-test/datatype/ddt_pack
-test/datatype/external32
-test/datatype/to_self
-test/datatype/checksum
-test/datatype/position
-test/datatype/ddt_raw
 test/datatype/opal_datatype_test
-test/datatype/position_noncontig
-test/datatype/unpack_ooo
+test/datatype/opal_datatype_bigcount
+test/datatype/opal_ddt_api
 test/datatype/unpack_hetero
 
 test/event/signal-test
 test/event/event-test
 test/event/time-test
 
-test/monitoring/monitoring_test
-test/monitoring/check_monitoring
-test/monitoring/example_reduce_count
-test/monitoring/test_overhead
-test/monitoring/test_pvar_access
-
-test/mpi/environment/chello
+test/mpool/mpool_memkind
 
 test/runtime/parse_context
 test/runtime/sigchld
@@ -479,10 +521,9 @@ test/runtime/start_shut
 test/runtime/opal_init_finalize
 test/runtime/orte_init_finalize
 
-test/spc/spc_test
-
 test/threads/opal_condition
 test/threads/opal_thread
+test/threads/opal_atomic_thread_bench
 
 test/util/aaa
 test/util/test_session_dir_out
@@ -497,7 +538,7 @@ test/util/orte_session_dir
 test/util/orte_sys_info
 test/util/orte_universe_setup_file_io
 test/util/opal_basename
-test/util/ompi_numtostr
+test/util/opal_numtostr
 test/util/ompi_pack
 test/util/test-file
 test/util/opal_sos
@@ -506,6 +547,29 @@ test/util/opal_path_nfs.out
 test/util/opal_bit_ops
 test/util/bipartite_graph
 test/util/opal_sha256
+test/util/opal_json
+test/util/opal_alfg
+test/util/opal_arch
+test/util/opal_cmd_line
+test/util/opal_crc
+test/util/opal_environ
+test/util/opal_fd
+test/util/opal_few
+test/util/opal_getcwd
+test/util/opal_info
+test/util/opal_info_subscriber
+test/util/opal_keyval_parse
+test/util/opal_malloc
+test/util/opal_net
+test/util/opal_os_dirpath
+test/util/opal_output
+test/util/opal_path
+test/util/opal_printf
+test/util/opal_proc
+test/util/opal_qsort
+test/util/opal_string_copy
+test/util/opal_sys_limits
+test/util/opal_uri
 
 opal/test/reachable/reachable_netlink
 opal/test/reachable/reachable_weighted
@@ -517,6 +581,10 @@ docs/_static
 docs/_static/css/custom.css
 docs/_templates
 docs/man-openmpi/man3/bindings
+docs/llms-build
+docs/llms-build.stamp
+docs/llms-det-a
+docs/llms-det-b
 docs/*.inv
 
 # Common Python virtual environment and cache directory names
@@ -533,6 +601,9 @@ docs/schizo-ompi-rst-content
 docs/html
 docs/man
 
+# other doc RST files to ignore as they are generated
+docs/code-of-conduct.rst
+
 # Generated C Bindings
 ompi/mpi/c/*_generated*.c
 
diff --git a/.mailmap b/.mailmap
index 0b2e1684f6d..86031b5c04d 100644
--- a/.mailmap
+++ b/.mailmap
@@ -139,3 +139,6 @@ Brian Barrett <brian@bbarrett.org>
 Andrii Bilokur <abilokur@nvidia.com> B-a-S <abilokur@nvidia.com>
 
 Kento Hasegawa <hasegawa.kento@fujitsu.com> hasegawa.kento <hasegawa.kento@fujitsu.com>
+
+Brelle Emmanuel <emmanuel.brelle@bull.com> Brelle Emmanuel <emmanuel.brelle@atos.net>
+Brelle Emmanuel <emmanuel.brelle@bull.com> Brelle Emmanuel <emmanuel.brelle@eviden.com>
diff --git a/.readthedocs-pre-create-environment.sh b/.readthedocs-pre-create-environment.sh
index cc461ac2b13..7b141f36df3 100755
--- a/.readthedocs-pre-create-environment.sh
+++ b/.readthedocs-pre-create-environment.sh
@@ -29,3 +29,13 @@ cp -rp $PRRTE_RST_SRC_DIR $PRRTE_RST_TARGET_DIR
 
 cd docs
 python3 ./generate-mpi-man3-bindings.py --srcdir . --builddir .
+python3 ./generate-code-of-conduct-rst.py --input ../.github/CODE_OF_CONDUCT.md --output code-of-conduct.rst
+
+# Generate the LLM-friendly artifacts into the build-tree staging directory
+# (must run after the man3 bindings, whose generated RST it include-expands).
+# A "build-finished" hook in conf.py copies the staging tree into the HTML
+# output during the sphinx-build that Read the Docs runs.  The URL base for
+# the generated links is taken from READTHEDOCS_CANONICAL_URL, so they use the
+# correct version slug (e.g. .../en/main/).
+python3 ./generate-llm-docs.py --srcdir . --builddir .
+
diff --git a/3rd-party/openpmix b/3rd-party/openpmix
index 53fce423d5d..cb89026c747 160000
--- a/3rd-party/openpmix
+++ b/3rd-party/openpmix
@@ -1 +1 @@
-Subproject commit 53fce423d5d6b25798ed1f32837671dc55d0230d
+Subproject commit cb89026c747e8540692eed29b3880e67b7ba9aa2
diff --git a/3rd-party/prrte b/3rd-party/prrte
index 2d9b0aaaeea..a2d2b039a4f 160000
--- a/3rd-party/prrte
+++ b/3rd-party/prrte
@@ -1 +1 @@
-Subproject commit 2d9b0aaaeea49a0e7850aed95e5ace9340c7d847
+Subproject commit a2d2b039a4f0de9af2b36be90283591c82cdc794
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000000..7a99923298a
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,369 @@
+<!--
+  Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+
+  $COPYRIGHT$
+
+  Additional copyrights may follow
+
+  $HEADER$
+-->
+
+# AGENTS.md
+
+Guidance for AI coding agents (and the humans driving them) working in
+the Open MPI source tree. This file is an *orientation map*, not the
+full rulebook: the authoritative, human-maintained documentation lives
+under [`docs/developers/`](docs/developers/) and
+[`docs/contributing.rst`](docs/contributing.rst) (rendered at
+<https://docs.open-mpi.org/>). When this file and those docs disagree,
+**the docs win** — and please fix this file.
+
+AI-assisted contributions are welcome. But Open MPI runs on the largest
+supercomputers in the world and across a huge range of operating
+systems and hardware. We want careful, portable, performant code — not
+plausible-looking code that solves one problem in one environment at the
+expense of others. Hold yourself to the same bar as a thoughtful human
+contributor.
+
+## What Open MPI is
+
+Open MPI is an open source implementation of the [Message Passing
+Interface (MPI) specification](https://www.mpi-forum.org/docs/) — a
+high-level library for sending discrete, typed messages between
+processes, independent of the underlying network or OS. It also
+includes a run-time system that launches and manages the lifecycle of
+many processes across many hosts as a single MPI "job".
+
+## The mental model: three projects
+
+The code base is divided into three *projects*, which are strict
+abstraction barriers — each compiles to its own library with a one-way
+dependency order:
+
+```
+OSHMEM  (liboshmem)   OpenSHMEM API layer
+   │  depends on
+OMPI    (libmpi)      MPI API layer + language bindings
+   │  depends on
+OPAL    (libopen-pal) portability layer (OS/arch abstractions)
+```
+
+- **OPAL** — portability primitives. Symbols prefixed `opal_` / `OPAL_`.
+  This is where most OS/arch `#if` blocks belong.
+- **OMPI** — everything the MPI standard mandates: the language bindings
+  (C and several Fortran flavors) on top, MCA frameworks
+  underneath. Symbols prefixed `ompi_` / `OMPI_`; only *official* MPI
+  symbols get `MPI_` / `mpi_`.
+- **OSHMEM** — the OpenSHMEM API layer; sibling to OMPI, changes slowly.
+  Symbols prefixed `oshmem_` / `OSHMEM_`.
+
+**Linker boundary (a real, hard error if you violate it):** code in a
+lower layer *cannot* directly call functions in a higher layer. OPAL
+cannot call OMPI or OSHMEM; OMPI cannot call OSHMEM. The legal way for a
+lower layer to reach upward is a **callback function pointer** handed
+down from the higher layer. Direct upward calls fail to resolve at link
+time.
+
+## MCA: the Modular Component Architecture
+
+OPAL, OMPI, and OSHMEM are built almost entirely out of MCA plugins.
+Read [`docs/developers/terminology.rst`](docs/developers/terminology.rst)
+and the MCA section it points to before doing real work. The hierarchy:
+
+- **Project** → **Framework** → **Component** → **Module** (runtime
+  instance, like a C++ object). Each level is isolated from its
+  siblings; a framework exposes a top-level header for its public API.
+- Example: `opal/mca/btl/` is the BTL framework in OPAL;
+  `opal/mca/btl/tcp/` is one component within it.
+- **MCA parameters** let users change behavior at run time (env var,
+  file, CLI). **Prefer adding an MCA parameter over hard-coding a
+  constant** — this is idiomatic and expected here.
+
+## Golden rules (the things agents most often get wrong)
+
+From [`docs/developers/source-code.rst`](docs/developers/source-code.rst)
+and [`docs/contributing.rst`](docs/contributing.rst):
+
+- **Prefix rule.** Filenames are prefixed `<framework>_<component>`.
+  Public symbols in a component are prefixed
+  `<project>_<framework>_<component>` (`<project>` ∈ `mca`, `opal`,
+  `ompi`, `oshmem`). Non-public symbols must be `static` or otherwise
+  kept out of global scope. When in doubt, add the prefix.
+- **Include `<level>_config.h` first** — `opal_config.h`,
+  `ompi_config.h`, or `oshmem_config.h` for the layer you're in — as the
+  very first `#include`, before any system header.
+- **Use the `__opal_attribute_*__` macros for compiler attributes.**
+  [`opal/include/opal_config_bottom.h`](opal/include/opal_config_bottom.h),
+  pulled in transitively by `opal_config.h`, defines portable wrappers —
+  `__opal_attribute_unused__`, `__opal_attribute_noreturn__`,
+  `__opal_attribute_format__`, `__opal_attribute_deprecated__`, and many
+  more — that expand to the appropriate `__attribute__((...))` on
+  compilers that support it and to nothing elsewhere. Reach for these
+  (for example, to mark an unused function parameter) rather than writing
+  a bare `__attribute__` or leaving a warning unaddressed.
+- **MPI back-end code must never call public `MPI_*()` APIs.** The
+  bindings are thin wrappers; call the internal `ompi_*` routines, not
+  the user-facing entry points.
+- **New files need the standard copyright/license header.** Copy the
+  multi-institution BSD header block — including the `$COPYRIGHT$` and
+  `$HEADER$` tokens — from a neighboring file. If you substantially
+  change an existing file, add your copyright line to its block.
+- **`#define` logical macros to `0` or `1`; never `#undef` them.** Test
+  with `#if FOO`, not `#ifdef FOO`, so a misspelling is a compiler
+  error, not a silent false.
+- **Put constants on the left** of equality tests: `if (NULL == ptr)`.
+- **Always brace blocks**, even one-liners. **4-space indents, never a
+  literal tab character**, in any language.
+- C11 is required (Open MPI ≥ 6.0): C++-style `//` comments and C99
+  mixed declarations are allowed and preferred. Fortran has no formal
+  style — match the surrounding code.
+- **Stay compiler-warning-free.** Open MPI strives to build with zero
+  compiler warnings. Do not introduce code that adds new warnings.
+- **Ignore new build products; never commit them.** If your change makes
+  the build emit something new — a test binary, a generated source or
+  header, a wrapper data file — add it to the top-level
+  [`.gitignore`](.gitignore), in the block for its directory, matching
+  the surrounding path style (repo-root-relative, no leading slash).
+  Open MPI keeps essentially all ignores in that one file; per-directory
+  `.gitignore` files are a rare exception, so don't create one. After a
+  clean build, `git status` must be clean — an untracked generated file
+  means you missed an entry, and committing the artifact itself is never
+  the fix.
+
+## Generated code: edit the source, not the output
+
+The MPI C/Fortran bindings are **generated at build time** by the Python
+generator under [`ompi/mpi/bindings/`](ompi/mpi/bindings/)
+(`bindings.py` + `ompi_bindings/`), driven in part by official MPI
+symbol/signature data pulled from the MPI Forum's `pympistandard`. If
+you need to change a binding's behavior, change the **generator,
+templates, or the back-end implementation** — never the emitted `.c`/`.h`
+files.
+
+## Do NOT hand-edit
+
+- **`3rd-party/` and the git submodules** (embedded OpenPMIx, and the
+  Open MPI *fork* of PRRTE). Fixes belong upstream, not patched in here.
+- **Autotools-generated output** — `configure`, `Makefile.in`,
+  `config.status`, anything produced by `./autogen.pl`. Edit
+  `configure.ac`, `Makefile.am`, or the m4 in [`config/`](config/)
+  instead.
+- **Generated MPI bindings** — see the section above.
+- **Pre-rendered docs** — shipped HTML and generated man pages. Edit the
+  RST sources under [`docs/`](docs/).
+
+## Build and test
+
+Open MPI uses the GNU Autotools (Autoconf / Automake / Libtool). From a
+Git clone:
+
+```sh
+./autogen.pl            # regenerate the build system (one-time / after build-system changes)
+./configure --prefix=/path/to/install
+make -j                 # full builds are SLOW
+make install
+```
+
+Out-of-tree (VPATH) builds are not required, but they are often helpful
+for sanity checks because they avoid perturbing the source tree:
+
+```sh
+mkdir build && cd build
+../configure --prefix=/path/to/install
+make -j
+```
+
+See [`docs/developers/building-open-mpi.rst`](docs/developers/building-open-mpi.rst)
+and the [install docs](docs/installing-open-mpi/) for options.
+
+## Modifying the configure / build system
+
+Editing the build system means regenerating it — `make` alone can't,
+and trying will wedge the tree. If you change `configure.ac` or any
+`config/*.m4` file (including the embedded oac/Autotools macros), the
+change does not take effect until the build system is regenerated. Do
+not rely on a plain `make`: Open MPI builds in maintainer mode, so
+`make` auto-triggers a partial in-tree Autotools regeneration that
+frequently fails (e.g., unexpanded `OAC_*` macros, `config.status`
+errors) and can leave the tree half-regenerated and
+unbuildable. Instead, regenerate and reconfigure explicitly:
+
+```sh
+./autogen.pl
+./configure <same options as the original configure>
+make -j
+```
+
+Recover the original configure invocation options from the existing
+tree with `./config.status --config` (or read the header of
+`config.log`). This process is slow but mandatory after any
+build-system source change — there is no safe shortcut.
+
+Note that editing `Makefile.am` files do *not* require the full
+`autogen.pl` + `./configure` process.  A simple `make` will regenerate
+the relevant `Makefile[.in]` files and then complete the build
+successfully.
+
+**"Did I break it?" — layered:**
+
+1. **Build cleanly.** A clean `make` after your change is the baseline.
+   Open MPI is highly configurable at build time: many components,
+   source files, directories, and generated artifacts are selected or
+   omitted by `configure` and Automake based on the local environment.
+   For any change to code or documentation that might be conditionally
+   built, verify that your configured build is actually compiling or
+   generating the thing you changed; do not assume this can be checked
+   only by looking for `#if` blocks.
+2. **Documentation-only changes can be narrower.** If the change is
+   wholly under [`docs/`](docs/), it is often enough to configure with
+   Sphinx support and run `make` in the `docs/` build directory instead
+   of doing a full build, install, smoke test, or `make check`. Make
+   sure Sphinx was really enabled by `configure`; one practical check is
+   that `SPHINX_BUILD` in `config.status` names a valid executable.
+3. **Quick smoke test.** After `make install`, put your `--prefix`'s
+   `bin/` on your `PATH`, then build and run an example on the local
+   host:
+
+   ```sh
+   cd examples && make        # compiles against the installed mpicc/mpifort wrappers
+   mpirun --np 2 ./hello_c    # smallest launch + MPI_Init/Finalize sanity check
+   mpirun --np 2 ./ring_c     # adds real point-to-point messaging
+   ```
+4. **Deeper validation** when your environment supports it: `make check`
+   and the programs under [`test/`](test/). Be aware that the full suite
+   and realistic MPI jobs frequently need a proper launcher and/or
+   multiple hosts/specialized hardware — **do not assume you can run all
+   of it locally, and don't report untested code as verified.**
+
+**Test across environments when you can.** Portability across a wide
+variety of environments is a core Open MPI goal. The primary development
+environments are common Linux distributions and macOS, but the code is
+expected to run far more widely. When container-based tooling is
+available, it can be a practical way to reproduce, diagnose, and test
+user-space behavior specific to an environment you aren't running
+natively — for example, using Docker on macOS to exercise Linux
+user-space code paths. (Containers don't replace real
+network/hardware/launcher testing, but they're useful for OS and
+user-space differences.)
+
+**Add tests for new code.** Whenever practical, add unit tests under
+[`test/`](test/) that are wired into `make check` (and therefore run in
+CI). Prefer a `make check`-able test over a manual one-off so the
+coverage sticks and regressions are caught automatically.
+
+**Never bend a test to accommodate a bug.** Do not weaken, skip, or
+rewrite an existing test — and do not craft a new one — merely to make
+buggy behavior pass. Tests encode intended behavior: when one fails, the
+default assumption is that the code is wrong, not the test. If you find a
+genuine bug in the code base, identify it, report it, and where
+appropriate fix it — don't paper over it in the test suite.
+
+## Performance discipline
+
+Performance is paramount: short-message **latency** and large-message
+**bandwidth** are headline metrics, along with the ability to offload
+work to networking/GPU hardware so the CPU can make progress
+elsewhere. Microseconds — sometimes nanoseconds — matter, and much of
+the hot path uses OS-bypass techniques talking directly to network,
+CUDA, and ROCm hardware.
+
+Concrete rules for hot paths:
+
+- **Don't add allocations, locks, or branches to the critical
+  send/receive path** without a clear, measured justification.
+- **Guard debug output and expensive assertions behind
+  `OPAL_ENABLE_DEBUG`** so release builds pay nothing for them.
+- **Prefer an MCA parameter** to a hard-coded constant when a value
+  might need tuning per environment.
+- Keep environment-specific optimization where it belongs — generally in
+  OPAL or in the hardware-specific component — not smeared across
+  portable MPI logic.
+
+## Working in a shared repository
+
+Don't assume you're the only agent (or person) using this clone. In
+particular, if you're working in a **git worktree**, other worktrees may
+be active against the same underlying repository at the same time. Avoid
+repo-wide git commands that reach outside your own working area and can
+disrupt others — for example, `git worktree prune`, or `git stash`
+(which writes to the repository-wide stash ref shared by all worktrees).
+Keep your git operations scoped to your own branch and worktree.
+
+As a narrow exception, creating a **new branch** when you need to park
+work in progress (for example, instead of `git stash`) is fine. Just be
+careful not to collide with branches that other agents or people may be
+using in the same clone — pick a clearly-scoped, unlikely-to-clash name.
+
+## Contributing
+
+Authoritative process:
+[`docs/contributing.rst`](docs/contributing.rst). Highlights agents must
+honor:
+
+- **Sign off every commit.** Each commit needs a `Signed-off-by:` line
+  per the Contributor's Declaration — use `git commit -s`. Commits
+  without it are not accepted. This applies to AI-assisted work too: the
+  human submitter certifies the contribution.
+- **Commit messages:** a short first line saying *what* changed, then a
+  body explaining *why*. Open MPI does **not** use Conventional Commits
+  (`feat:`/`fix:` prefixes) — write prose. Don't add AI tooling
+  attribution. Wrap commit-message lines at around 75 characters.
+- **Keep incidental fixes as their own commits.** Small "drive-by" bug
+  fixes you notice while working on something else are welcome, but it is
+  usually best to land them as standalone commits, separate from your
+  main change, so each can be evaluated and reviewed on its own. One
+  logical change per commit keeps history reviewable and easy to bisect.
+- **Branch flow:** land on `main` first via a GitHub pull request, then
+  cherry-pick to the relevant release branch(es) `vMAJOR.MINOR.x` with a
+  `(cherry picked from commit ...)` line at the end of the commit
+  message; use `git cherry-pick -x` to add it. Open MPI always lands
+  commits on `main` and release branches through pull requests; never
+  push directly to those branches. Never commit features directly to a
+  release branch. See
+  [`docs/developers/git-github.rst`](docs/developers/git-github.rst).
+- **Update the docs and the changelog** when user-visible behavior
+  changes: RST under [`docs/`](docs/), and a release-notes entry under
+  [`docs/release-notes/changelog/`](docs/release-notes/changelog/)
+  (`vMAJOR.MINOR.x.rst`).
+- **In user-facing docs, the package's name is "Open MPI."** When
+  referring to this software package as a whole in user-facing
+  documentation, always write the formal name **Open MPI** — never the
+  abbreviation "OMPI". ("OMPI" is correct only as the internal name of
+  the middle project layer (OPAL → OMPI → OSHMEM) and its `ompi_` /
+  `OMPI_` symbol prefix — never as a public-facing name for the
+  package.)
+- **Keep the LLM-friendly docs in sync.** The machine-readable MPI API
+  artifacts (catalog, corpora, per-symbol pages, manifest) regenerate
+  automatically from the man-page RST and binding metadata, so they
+  cannot drift. The *curated* sources under
+  [`docs/llms-src/`](docs/llms-src/) (the interface guide, examples, and
+  the `ompi_info` runtime-introspection guide) can: when a PR changes
+  public MPI documentation, update the affected curated files when
+  relevant. If you change the curated examples or the
+  JSON Schemas, regenerate
+  `specs/llms-friendly-docs/sample-records.jsonl` so `make check`
+  (which validates the artifacts) still passes. See
+  [`docs/developers/llm-friendly-docs.rst`](docs/developers/llm-friendly-docs.rst).
+
+## Repository map
+
+| Path | What's there |
+|------|--------------|
+| `opal/` | OPAL portability layer (`opal/mca/` = its frameworks) |
+| `ompi/` | OMPI / MPI layer; `ompi/mpi/` = language bindings, `ompi/mca/` = frameworks |
+| `oshmem/` | OpenSHMEM layer |
+| `3rd-party/` | embedded upstreams + submodules (OpenPMIx, PRRTE fork) — don't hand-edit |
+| `config/` | m4 macros for Autoconf / Automake / Libtool |
+| `docs/` | all RST documentation (Sphinx); `docs/developers/` is the dev guide |
+| `examples/` | small MPI example programs (good smoke tests) |
+| `test/` | unit / functional tests |
+| `contrib/` | unsupported contributed scripts and tools |
+
+## When in doubt
+
+- Match the surrounding code's style and conventions — this is an old,
+  multi-author code base with established patterns.
+- Read the relevant [`docs/developers/`](docs/developers/) page before
+  inventing a new pattern.
+- Ask on the developer mailing list / a GitHub issue for anything large
+  before writing it; see [`docs/contributing.rst`](docs/contributing.rst).
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 120000
index 00000000000..47dc3e3d863
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/Doxyfile b/Doxyfile
deleted file mode 100644
index e8c88d33574..00000000000
--- a/Doxyfile
+++ /dev/null
@@ -1,1099 +0,0 @@
-# Doxyfile 1.3.4
-#
-# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
-#                         University Research and Technology
-#                         Corporation.  All rights reserved.
-# Copyright (c) 2004-2005 The University of Tennessee and The University
-#                         of Tennessee Research Foundation.  All rights
-#                         reserved.
-# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
-#                         University of Stuttgart.  All rights reserved.
-# Copyright (c) 2004-2005 The Regents of the University of California.
-#                         All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project
-#
-# All text after a hash (#) is considered a comment and will be ignored
-# The format is:
-#       TAG = value [value, ...]
-# For lists items can also be appended using:
-#       TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (" ")
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
-# by quotes) that should identify the project.
-
-PROJECT_NAME           = Open MPI
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number.
-# This could be handy for archiving the generated documentation or
-# if some version control system is used.
-
-PROJECT_NUMBER         = 0.1.1
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
-# base path where the generated documentation will be put.
-# If a relative path is entered, it will be relative to the location
-# where doxygen was started. If left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       = doxygen
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# The default language is English, other supported languages are:
-# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch,
-# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en
-# (Japanese with English messages), Korean, Norwegian, Polish, Portuguese,
-# Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian.
-
-OUTPUT_LANGUAGE        = English
-
-# This tag can be used to specify the encoding used in the generated output.
-# The encoding is not always determined by the language that is chosen,
-# but also whether or not the output is meant for Windows or non-Windows users.
-# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES
-# forces the Windows encoding (this is the default for the Windows binary),
-# whereas setting the tag to NO uses a Unix-style encoding (the default for
-# all platforms other than Windows).
-
-USE_WINDOWS_ENCODING   = NO
-
-# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
-# include brief member descriptions after the members that are listed in
-# the file and class documentation (similar to JavaDoc).
-# Set to NO to disable this.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will
-# prepend the brief description of a member or function before the
-# detailed description.  Note: if both HIDE_UNDOC_MEMBERS and
-# BRIEF_MEMBER_DESC are set to NO, the brief descriptions will be
-# completely suppressed.
-
-REPEAT_BRIEF           = YES
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# Doxygen will generate a detailed section even if there is only a brief
-# description.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show
-# all inherited members of a class in the documentation of that class
-# as if those members were ordinary class members. Constructors,
-# destructors and assignment operators of the base classes will not be
-# shown.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
-# path before files name in the file list and in the header files. If set
-# to NO the shortest path that makes the file name unique will be used.
-
-FULL_PATH_NAMES        = YES
-
-# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
-# can be used to strip a user-defined part of the path. Stripping is
-# only done if one of the specified strings matches the left-hand part of
-# the path. It is allowed to use relative paths in the argument list.
-
-STRIP_FROM_PATH        =
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
-# (but less readable) file names. This can be useful is your file systems
-# doesn't support long names like on DOS, Mac, or CD-ROM.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
-# will interpret the first line (until the first dot) of a JavaDoc-style
-# comment as the brief description. If set to NO, the JavaDoc
-# comments will behave just like the Qt-style comments (thus requiring an
-# explict @brief command for a brief description.
-
-JAVADOC_AUTOBRIEF      = YES
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
-# treat a multi-line C++ special comment block (i.e. a block of //! or ///
-# comments) as a brief description. This used to be the default behaviour.
-# The new default is to treat a multi-line C++ comment block as a detailed
-# description. Set this tag to YES if you prefer the old behaviour instead.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# If the DETAILS_AT_TOP tag is set to YES then Doxygen
-# will output the detailed description near the top, like JavaDoc.
-# If set to NO, the detailed description appears after the member
-# documentation.
-
-DETAILS_AT_TOP         = NO
-
-# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
-# member inherits the documentation from any documented member that it
-# reimplements.
-
-INHERIT_DOCS           = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES, then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab.
-# Doxygen uses this value to replace tabs by spaces in code fragments.
-
-TAB_SIZE               = 8
-
-# This tag can be used to specify a number of aliases that acts
-# as commands in the documentation. An alias has the form "name=value".
-# For example adding "sideeffect=\par Side Effects:\n" will allow you to
-# put the command \sideeffect (or @sideeffect) in the documentation, which
-# will result in a user-defined paragraph with heading "Side Effects:".
-# You can put \n's in the value part of an alias to insert newlines.
-
-ALIASES                =
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of
-# C sources only. Doxygen will then generate output that is more
-# tailored for C.  For instance, some of the names that are used will
-# be different. The list of all members will be omitted, etc.
-
-OPTIMIZE_OUTPUT_FOR_C  = YES
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of
-# Java sources only. Doxygen will then generate output that is more
-# tailored for Java.  For instance, namespaces will be presented as
-# packages, qualified scopes will look different, etc.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
-# the same type (for instance a group of public functions) to be put as a
-# subgroup of that type (e.g. under the Public Functions section). Set it to
-# NO to prevent subgrouping. Alternatively, this can be done per class using
-# the \nosubgrouping command.
-
-SUBGROUPING            = YES
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
-# documentation are documented, even if no documentation was available.
-# Private class members and static file members will be hidden unless
-# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
-
-EXTRACT_ALL            = NO
-
-# If the EXTRACT_PRIVATE tag is set to YES all private members of a
-# class will be included in the documentation.
-
-EXTRACT_PRIVATE        = NO
-
-# If the EXTRACT_STATIC tag is set to YES all static members of a file
-# will be included in the documentation.
-
-EXTRACT_STATIC         = YES
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
-# defined locally in source files will be included in the documentation.
-# If set to NO only classes defined in header files are included.
-
-EXTRACT_LOCAL_CLASSES  = YES
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
-# undocumented members of documented classes, files or namespaces.
-# If set to NO (the default) these members will be included in the
-# various overviews, but no documentation section is generated.
-# This option has no effect if EXTRACT_ALL is enabled.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy.
-# If set to NO (the default) these classes will be included in the various
-# overviews. This option has no effect if EXTRACT_ALL is enabled.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
-# friend (class|struct|union) declarations.
-# If set to NO (the default) these declarations will be included in the
-# documentation.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
-# documentation blocks found inside the body of a function.
-# If set to NO (the default) these blocks will be appended to the
-# function's detailed documentation block.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation
-# that is typed after a \internal command is included. If the tag is set
-# to NO (the default) then the documentation will be excluded.
-# Set it to YES to include the internal documentation.
-
-INTERNAL_DOCS          = NO
-
-# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
-# file names in lower-case letters. If set to YES upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# users are advised to set this option to NO.
-
-CASE_SENSE_NAMES       = YES
-
-# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
-# will show members with their full class and namespace scopes in the
-# documentation. If set to YES the scope will be hidden.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
-# will put a list of the files that are included by a file in the documentation
-# of that file.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
-# is inserted in the documentation for inline members.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
-# will sort the (detailed) documentation of file and class members
-# alphabetically by member name. If set to NO the members will appear in
-# declaration order.
-
-SORT_MEMBER_DOCS       = YES
-
-# The GENERATE_TODOLIST tag can be used to enable (YES) or
-# disable (NO) the todo list. This list is created by putting \todo
-# commands in the documentation.
-
-GENERATE_TODOLIST      = YES
-
-# The GENERATE_TESTLIST tag can be used to enable (YES) or
-# disable (NO) the test list. This list is created by putting \test
-# commands in the documentation.
-
-GENERATE_TESTLIST      = YES
-
-# The GENERATE_BUGLIST tag can be used to enable (YES) or
-# disable (NO) the bug list. This list is created by putting \bug
-# commands in the documentation.
-
-GENERATE_BUGLIST       = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
-# disable (NO) the deprecated list. This list is created by putting
-# \deprecated commands in the documentation.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional
-# documentation sections, marked by \if sectionname ... \endif.
-
-ENABLED_SECTIONS       =
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
-# the initial value of a variable or define consists of for it to appear in
-# the documentation. If the initializer consists of more lines than specified
-# here it will be hidden. Use a value of 0 to hide initializers completely.
-# The appearance of the initializer of individual variables and defines in the
-# documentation can be controlled using \showinitializer or \hideinitializer
-# command in the documentation regardless of this setting.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
-# at the bottom of the documentation of classes and structs. If set to YES the
-# list will mention the files that were used to generate the documentation.
-
-SHOW_USED_FILES        = YES
-
-#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated
-# by doxygen. Possible values are YES and NO. If left blank NO is used.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated by doxygen. Possible values are YES and NO. If left blank
-# NO is used.
-
-WARNINGS               = YES
-
-# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
-# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
-# automatically be disabled.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some
-# parameters in a documented function, or documenting parameters that
-# don't exist or using markup commands wrongly.
-
-WARN_IF_DOC_ERROR      = YES
-
-# The WARN_FORMAT tag determines the format of the warning messages that
-# doxygen can produce. The string should contain the $file, $line, and $text
-# tags, which will be replaced by the file and line number from which the
-# warning originated and the warning text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning
-# and error messages should be written. If left blank the output is written
-# to stderr.
-
-WARN_LOGFILE           =
-
-#---------------------------------------------------------------------------
-# configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag can be used to specify the files and/or directories that contain
-# documented source files. You may enter file names like "myfile.cpp" or
-# directories like "/usr/src/myproject". Separate the files or directories
-# with spaces.
-
-INPUT                  = opal orte ompi
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
-# and *.h) to filter out the source-files in the directories. If left
-# blank the following patterns are tested:
-# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp
-# *.h++ *.idl *.odl *.cs *.php *.php3 *.inc
-
-FILE_PATTERNS          = *.c *.h *.cc *.dox
-
-# The RECURSIVE tag can be used to turn specify whether or not subdirectories
-# should be searched for input files as well. Possible values are YES and NO.
-# If left blank NO is used.
-
-RECURSIVE              = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-
-EXCLUDE                = opal/event
-
-# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
-# directories that are symbolic links (a Unix filesystem feature) are
-# excluded from the input.
-
-EXCLUDE_SYMLINKS       = YES
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-
-EXCLUDE_PATTERNS       = static-modules.h *config*.h ompi_stdint.h ltdl.h
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or
-# directories that contain example code fragments that are included (see
-# the \include command).
-
-EXAMPLE_PATH           =
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
-# and *.h) to filter out the source-files in the directories. If left
-# blank all files are included.
-
-EXAMPLE_PATTERNS       =
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude
-# commands irrespective of the value of the RECURSIVE tag.
-# Possible values are YES and NO. If left blank NO is used.
-
-EXAMPLE_RECURSIVE      = NO
-
-# The IMAGE_PATH tag can be used to specify one or more files or
-# directories that contain image that are included in the documentation (see
-# the \image command).
-
-IMAGE_PATH             =
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command <filter> <input-file>, where <filter>
-# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
-# input file. Doxygen will then use the output that the filter program writes
-# to standard output.
-
-INPUT_FILTER           =
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER) will be used to filter the input files when producing source
-# files to browse (i.e. when SOURCE_BROWSER is set to YES).
-
-FILTER_SOURCE_FILES    = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will
-# be generated. Documented entities will be cross-referenced with these sources.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body
-# of functions and classes directly in the documentation.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
-# doxygen to hide any special comment blocks from generated source code
-# fragments. Normal C and C++ comments will always remain visible.
-
-STRIP_CODE_COMMENTS    = NO
-
-# If the REFERENCED_BY_RELATION tag is set to YES (the default)
-# then for each documented function all documented
-# functions referencing it will be listed.
-
-REFERENCED_BY_RELATION = YES
-
-# If the REFERENCES_RELATION tag is set to YES (the default)
-# then for each documented function all documented entities
-# called/used by that function will be listed.
-
-REFERENCES_RELATION    = YES
-
-# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
-# will generate a verbatim copy of the header file for each class for
-# which an include is specified. Set to NO to disable this.
-
-VERBATIM_HEADERS       = YES
-
-#---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
-# of all compounds will be generated. Enable this if the project
-# contains a lot of classes, structs, unions or interfaces.
-
-ALPHABETICAL_INDEX     = NO
-
-# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
-# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
-# in which this list will be split (can be a number in the range [1..20])
-
-COLS_IN_ALPHA_INDEX    = 5
-
-# In case all classes in a project start with a common prefix, all
-# classes will be put under the same header in the alphabetical index.
-# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
-# should be ignored while generating the index headers.
-
-IGNORE_PREFIX          =
-
-#---------------------------------------------------------------------------
-# configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
-# generate HTML output.
-
-GENERATE_HTML          = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `html' will be used as the default path.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
-# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
-# doxygen will generate files with .html extension.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a personal HTML header for
-# each generated HTML page. If it is left blank doxygen will generate a
-# standard header.
-
-HTML_HEADER            =
-
-# The HTML_FOOTER tag can be used to specify a personal HTML footer for
-# each generated HTML page. If it is left blank doxygen will generate a
-# standard footer.
-
-HTML_FOOTER            =
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
-# style sheet that is used by each HTML page. It can be used to
-# fine-tune the look of the HTML output. If the tag is left blank doxygen
-# will generate a default style sheet
-
-HTML_STYLESHEET        =
-
-# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
-# files or namespaces will be aligned in HTML using tables. If set to
-# NO a bullet list will be used.
-
-HTML_ALIGN_MEMBERS     = YES
-
-# If the GENERATE_HTMLHELP tag is set to YES, additional index files
-# will be generated that can be used as input for tools like the
-# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)
-# of the generated HTML documentation.
-
-GENERATE_HTMLHELP      = NO
-
-# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
-# be used to specify the file name of the resulting .chm file. You
-# can add a path in front of the file if the result should not be
-# written to the html output dir.
-
-CHM_FILE               =
-
-# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
-# be used to specify the location (absolute path including file name) of
-# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
-# the HTML help compiler on the generated index.hhp.
-
-HHC_LOCATION           =
-
-# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
-# controls if a separate .chi index file is generated (YES) or that
-# it should be included in the master .chm file (NO).
-
-GENERATE_CHI           = NO
-
-# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
-# controls whether a binary table of contents is generated (YES) or a
-# normal table of contents (NO) in the .chm file.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members
-# to the contents of the HTML help documentation and to the tree view.
-
-TOC_EXPAND             = NO
-
-# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
-# top of each HTML page. The value NO (the default) enables the index and
-# the value YES disables it.
-
-DISABLE_INDEX          = NO
-
-# This tag can be used to set the number of enum values (range [1..20])
-# that doxygen will group on one line in the generated HTML documentation.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
-# generated containing a tree-like index structure (just like the one that
-# is generated for HTML Help). For this to work a browser that supports
-# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
-# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
-# probably better off using the HTML help feature.
-
-GENERATE_TREEVIEW      = YES
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
-# used to set the initial width (in pixels) of the frame in which the tree
-# is shown.
-
-TREEVIEW_WIDTH         = 250
-
-#---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
-# generate Latex output.
-
-GENERATE_LATEX         = YES
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `latex' will be used as the default path.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked. If left blank `latex' will be used as the default command name.
-
-LATEX_CMD_NAME         = latex
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
-# generate index for LaTeX. If left blank `makeindex' will be used as the
-# default command name.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
-# LaTeX documents. This may be useful for small projects and may help to
-# save some trees in general.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used
-# by the printer. Possible values are: a4, a4wide, letter, legal and
-# executive. If left blank a4wide will be used.
-
-#PAPER_TYPE             = a4wide
-PAPER_TYPE             = letter
-
-# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
-# packages that should be included in the LaTeX output.
-
-EXTRA_PACKAGES         =
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
-# the generated latex document. The header should contain everything until
-# the first chapter. If it is left blank doxygen will generate a
-# standard header. Notice: only use this tag if you know what you are doing!
-
-LATEX_HEADER           =
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
-# is prepared for conversion to pdf (using ps2pdf). The pdf file will
-# contain links (just like the HTML output) instead of page references
-# This makes the output suitable for online browsing using a pdf viewer.
-
-PDF_HYPERLINKS         = YES
-
-# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
-# plain latex in the generated Makefile. Set this option to YES to get a
-# higher quality PDF documentation.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
-# command to the generated LaTeX files. This will instruct LaTeX to keep
-# running if errors occur, instead of asking the user for help.
-# This option is also used when generating formulas in HTML.
-
-LATEX_BATCHMODE        = NO
-
-# If LATEX_HIDE_INDICES is set to YES then doxygen will not
-# include the index chapters (such as File Index, Compound Index, etc.)
-# in the output.
-
-LATEX_HIDE_INDICES     = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
-# The RTF output is optimised for Word 97 and may not look very pretty with
-# other RTF readers or editors.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `rtf' will be used as the default path.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
-# RTF documents. This may be useful for small projects and may help to
-# save some trees in general.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
-# will contain hyperlink fields. The RTF file will
-# contain links (just like the HTML output) instead of page references.
-# This makes the output suitable for online browsing using WORD or other
-# programs which support those fields.
-# Note: wordpad (write) and others do not support links.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's
-# config file, i.e. a series of assigments. You only have to provide
-# replacements, missing definitions are set to their default value.
-
-RTF_STYLESHEET_FILE    =
-
-# Set optional variables used in the generation of an rtf document.
-# Syntax is similar to doxygen's config file.
-
-RTF_EXTENSIONS_FILE    =
-
-#---------------------------------------------------------------------------
-# configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
-# generate man pages
-
-GENERATE_MAN           = YES
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `man' will be used as the default path.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to
-# the generated man pages (default is the subroutine's section .3)
-
-MAN_EXTENSION          = .3
-
-# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
-# then it will generate one additional man file for each entity
-# documented in the real man page(s). These additional files
-# only source the real man page, but without them the man command
-# would be unable to find the correct page. The default is NO.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES Doxygen will
-# generate an XML file that captures the structure of
-# the code including all documentation. Note that this
-# feature is still experimental and incomplete at the
-# moment.
-
-GENERATE_XML           = NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `xml' will be used as the default path.
-
-XML_OUTPUT             = xml
-
-# The XML_SCHEMA tag can be used to specify an XML schema,
-# which can be used by a validating XML parser to check the
-# syntax of the XML files.
-
-XML_SCHEMA             =
-
-# The XML_DTD tag can be used to specify an XML DTD,
-# which can be used by a validating XML parser to check the
-# syntax of the XML files.
-
-XML_DTD                =
-
-#---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
-# generate an AutoGen Definitions (see autogen.sf.net) file
-# that captures the structure of the code including all
-# documentation. Note that this feature is still experimental
-# and incomplete at the moment.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES Doxygen will
-# generate a Perl module file that captures the structure of
-# the code including all documentation. Note that this
-# feature is still experimental and incomplete at the
-# moment.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
-# the necessary Makefile rules, Perl scripts and LaTeX code to be able
-# to generate PDF and DVI output from the Perl module output.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
-# nicely formatted so it can be parsed by a human reader.  This is useful
-# if you want to understand what is going on.  On the other hand, if this
-# tag is set to NO the size of the Perl module output will be much smaller
-# and Perl will parse it just the same.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file
-# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
-# This is useful so different doxyrules.make files included by the same
-# Makefile don't overwrite each other's variables.
-
-PERLMOD_MAKEVAR_PREFIX =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
-# evaluate all C-preprocessor directives found in the sources and include
-# files.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
-# names in the source code. If set to NO (the default) only conditional
-# compilation will be performed. Macro expansion can be done in a controlled
-# way by setting EXPAND_ONLY_PREDEF to YES.
-
-MACRO_EXPANSION        = NO
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
-# then the macro expansion is limited to the macros specified with the
-# PREDEFINED and EXPAND_AS_PREDEFINED tags.
-
-EXPAND_ONLY_PREDEF     = NO
-
-# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
-# in the INCLUDE_PATH (see below) will be search if a #include is found.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by
-# the preprocessor.
-
-INCLUDE_PATH           =
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will
-# be used.
-
-INCLUDE_FILE_PATTERNS  =
-
-# The PREDEFINED tag can be used to specify one or more macro names that
-# are defined before the preprocessor is started (similar to the -D option of
-# gcc). The argument of the tag is a list of macros of the form: name
-# or name=definition (no spaces). If the definition and the = are
-# omitted =1 is assumed.
-
-PREDEFINED             = DOXYGEN
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
-# this tag can be used to specify a list of macro names that should be expanded.
-# The macro definition that is found in the sources will be used.
-# Use the PREDEFINED tag if you want to use a different macro definition.
-
-EXPAND_AS_DEFINED      =
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
-# doxygen's preprocessor will remove all function-like macros that are alone
-# on a line, have an all uppercase name, and do not end with a semicolon. Such
-# function macros are typically used for boiler-plate code, and will confuse the
-# parser if not removed.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration::addtions related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES option can be used to specify one or more tagfiles.
-# Optionally an initial location of the external documentation
-# can be added for each tagfile. The format of a tag file without
-# this location is as follows:
-#   TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-#   TAGFILES = file1=loc1 "file2 = loc2" ...
-# where "loc1" and "loc2" can be relative or absolute paths or
-# URLs. If a location is present for each tag, the installdox tool
-# does not have to be run to correct the links.
-# Note that each tag file must have a unique name
-# (where the name does NOT include the path)
-# If a tag file is not located in the directory in which doxygen
-# is run, you must also specify the path to the tagfile here.
-
-TAGFILES               =
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create
-# a tag file that is based on the input files it reads.
-
-GENERATE_TAGFILE       = doxygen/tagfile
-
-# If the ALLEXTERNALS tag is set to YES all external classes will be listed
-# in the class index. If set to NO only the inherited external classes
-# will be listed.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
-# in the modules index. If set to NO, only the current project's groups will
-# be listed.
-
-EXTERNAL_GROUPS        = YES
-
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of `which perl').
-
-PERL_PATH              = /usr/bin/perl
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
-# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base or
-# super classes. Setting the tag to NO turns the diagrams off. Note that this
-# option is superceded by the HAVE_DOT option below. This is only a fallback. It is
-# recommended to install and use dot, since it yields more powerful graphs.
-
-CLASS_DIAGRAMS         = YES
-
-# If set to YES, the inheritance and collaboration graphs will hide
-# inheritance and usage relations if the target is undocumented
-# or is not a class.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz, a graph visualization
-# toolkit from AT&T and Lucent Bell Labs. The other options in this section
-# have no effect if this option is set to NO (the default)
-
-HAVE_DOT               = NO
-
-# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for each documented class showing the direct and
-# indirect inheritance relations. Setting this tag to YES will force the
-# the CLASS_DIAGRAMS tag to NO.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for each documented class showing the direct and
-# indirect implementation dependencies (inheritance, containment, and
-# class references variables) of the class with other documented classes.
-
-COLLABORATION_GRAPH    = YES
-
-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
-# collaboration diagrams in a style similiar to the OMG's Unified Modeling
-# Language.
-
-UML_LOOK               = NO
-
-# If set to YES, the inheritance and collaboration graphs will show the
-# relations between templates and their instances.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
-# tags are set to YES then doxygen will generate a graph for each documented
-# file showing the direct and indirect include dependencies of the file with
-# other documented files.
-
-INCLUDE_GRAPH          = YES
-
-# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
-# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
-# documented header file showing the documented files that directly or
-# indirectly include this file.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will
-# generate a call dependency graph for every global function or class method.
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command.
-
-CALL_GRAPH             = NO
-
-# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
-# will graphical hierarchy of all classes instead of a textual one.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. Possible values are png, jpg, or gif
-# If left blank png will be used.
-
-DOT_IMAGE_FORMAT       = png
-
-# The tag DOT_PATH can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found on the path.
-
-DOT_PATH               =
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the
-# \dotfile command).
-
-DOTFILE_DIRS           =
-
-# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width
-# (in pixels) of the graphs generated by dot. If a graph becomes larger than
-# this value, doxygen will try to truncate the graph, so that it fits within
-# the specified constraint. Beware that most browsers cannot cope with very
-# large images.
-
-MAX_DOT_GRAPH_WIDTH    = 1024
-
-# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height
-# (in pixels) of the graphs generated by dot. If a graph becomes larger than
-# this value, doxygen will try to truncate the graph, so that it fits within
-# the specified constraint. Beware that most browsers cannot cope with very
-# large images.
-
-MAX_DOT_GRAPH_HEIGHT   = 1024
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
-# graphs generated by dot. A depth value of 3 means that only nodes reachable
-# from the root by following a path via at most 3 edges will be shown. Nodes that
-# lay further from the root node will be omitted. Note that setting this option to
-# 1 or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that a graph may be further truncated if the graph's image dimensions are
-# not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH and MAX_DOT_GRAPH_HEIGHT).
-# If 0 is used for the depth value (the default), the graph is not depth-constrained.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
-# generate a legend page explaining the meaning of the various boxes and
-# arrows in the dot generated graphs.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
-# remove the intermediate dot files that are used to generate
-# the various graphs.
-
-DOT_CLEANUP            = YES
-
-#---------------------------------------------------------------------------
-# Configuration::addtions related to the search engine
-#---------------------------------------------------------------------------
-
-# The SEARCHENGINE tag specifies whether or not a search engine should be
-# used. If set to NO the values of all tags below this one will be ignored.
-
-SEARCHENGINE           = NO
diff --git a/Makefile.am b/Makefile.am
index bff3c79c64f..49c6090a485 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -15,6 +15,7 @@
 # Copyright (c) 2017-2022 Amazon.com, Inc. or its affiliates.  All Rights reserved.
 #                         All Rights reserved.
 # Copyright (c) 2020      IBM Corporation.  All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -27,7 +28,7 @@
 # be required.
 SUBDIRS = config contrib 3rd-party $(MCA_PROJECT_SUBDIRS) test docs
 DIST_SUBDIRS = config contrib 3rd-party $(MCA_PROJECT_DIST_SUBDIRS) test docs
-EXTRA_DIST = README.md VERSION Doxyfile LICENSE autogen.pl AUTHORS
+EXTRA_DIST = README.md VERSION LICENSE autogen.pl AUTHORS
 
 include examples/Makefile.include
 
diff --git a/Makefile.mca-dso-check b/Makefile.mca-dso-check
new file mode 100644
index 00000000000..0a40afe2252
--- /dev/null
+++ b/Makefile.mca-dso-check
@@ -0,0 +1,93 @@
+# -*- makefile -*-
+#
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+# Shared Automake fragment for "make check" unit tests that initialize
+# OPAL (via opal_init() / opal_init_util()) or MPI (via MPI_Init(),
+# which additionally pulls in OMPI-level frameworks such as pml).
+#
+# When Open MPI is configured with --enable-mca-dso, MCA components are
+# built as standalone DSOs that are dlopen'ed at run time.  In an
+# installed tree they live in $libdir/openmpi; but "make check" runs
+# before "make install", so at test time they are scattered through the
+# build tree under libtool ".libs" directories.  Two things are needed
+# to make such tests work in an uninstalled --enable-mca-dso tree:
+#
+# 1. Point the Open MPI and PMIx MCA component search paths at the
+#    build-tree ".libs" directories that hold the freshly-built
+#    component DSOs, so opal_init() / MPI_Init() can find them.  A
+#    single Open MPI MCA search path (opal_mca_base_component_path)
+#    serves all of the Open MPI layers, so it lists the ".libs" dirs
+#    under opal/mca, ompi/mca, and oshmem/mca -- not just opal/mca.  The
+#    corresponding PMIx parameter uses PMIx's own "PMIX_MCA_" prefix and
+#    is named mca_base_component_path (no "opal_").  These are computed
+#    at test-run time (shell backquotes), not at Makefile-parse time,
+#    because the DSOs do not exist until the "all" prerequisite of "make
+#    check" has completed.
+#
+#    The PMIx search path is only set when Open MPI was built against its
+#    internal (bundled) PMIx (OPAL_USING_INTERNAL_PMIX); with an external
+#    PMIx there are no PMIx component DSOs to find under 3rd-party, and a
+#    stale internal-PMIx build left over in the tree must not be pointed
+#    at by a run that actually links the external PMIx library.
+#
+# 2. Make each component DSO's own load-time dependencies resolvable.
+#    Some components link against an "mca_common" shared library shared
+#    by a family of sibling components (e.g. io/ompio, fcoll/*, fbtl/*,
+#    and sharedfp/* all depend on libmca_common_ompio).  Those common
+#    libraries live under <project>/mca/common/<name>/.libs, which is
+#    NOT on the runtime library search path baked into the libtool test
+#    wrapper scripts: the wrapper only lists <project>/.libs (home of
+#    libopen-pal / libmpi / liboshmem).  On macOS this cannot be worked
+#    around via DYLD_LIBRARY_PATH in AM_TESTS_ENVIRONMENT, because
+#    System Integrity Protection strips DYLD_* when the /bin/sh wrapper
+#    is exec'ed.  So, before the tests run, symlink each project's
+#    mca_common shared libraries into that project's own .libs
+#    directory, which the wrapper already searches.
+#
+# Both mechanisms are harmless for a static (non-DSO) build: the symlink
+# step finds nothing to link, and although the component-search-path
+# variables may still be exported (libtool creates ".libs" dirs for
+# static convenience libraries too), they point at directories with no
+# loadable components, so nothing is dlopen'ed.  They are likewise
+# harmless for tests that never open a framework.  The symlinks live in
+# build-tree ".libs" directories and are removed automatically by
+# libtool's "clean-libtool" rule (rm -rf .libs).
+#
+# Note: the env var prefix really is "OMPI_MCA_" even for OPAL-level
+# parameters (OPAL_MCA_PREFIX == "OMPI_MCA_"); the full parameter name
+# is opal_mca_base_component_path.
+#
+# NOTE: this fragment defines an "all-local" rule.  Automake forbids two
+# definitions of the same *-local target in one Makefile.am, so a
+# Makefile.am that includes this fragment must NOT define its own
+# "all-local"; instead, add prerequisites to the mca-common-dso-symlinks
+# target below.
+
+AM_TESTS_ENVIRONMENT = \
+	ompi_mca_path="`find $(abs_top_builddir)/opal/mca $(abs_top_builddir)/ompi/mca $(abs_top_builddir)/oshmem/mca -type d -name .libs 2>/dev/null | sort | tr '\n' ':'`"; \
+	if test -n "$$ompi_mca_path"; then OMPI_MCA_opal_mca_base_component_path="$$ompi_mca_path"; export OMPI_MCA_opal_mca_base_component_path; fi; \
+	if test "@OPAL_USING_INTERNAL_PMIX@" = "1"; then \
+	  pmix_mca_path="`find $(abs_top_builddir)/3rd-party/openpmix/src/mca -type d -name .libs 2>/dev/null | sort | tr '\n' ':'`"; \
+	  if test -n "$$pmix_mca_path"; then PMIX_MCA_mca_base_component_path="$$pmix_mca_path"; export PMIX_MCA_mca_base_component_path; fi; \
+	fi;
+
+# See item 2 above.  Symlink each project's mca_common DSOs into that
+# project's own .libs directory (which the libtool wrappers already put
+# on the runtime library search path) so dlopen'ed components can
+# resolve their load-time dependencies.  Created "if missing" so
+# concurrent invocations (parallel "make check") never leave a symlink
+# transiently absent.
+all-local: mca-common-dso-symlinks
+.PHONY: mca-common-dso-symlinks
+mca-common-dso-symlinks:
+	$(AM_V_at)for proj in opal ompi oshmem; do \
+	  libs="$(abs_top_builddir)/$$proj/.libs"; test -d "$$libs" || continue; \
+	  find "$(abs_top_builddir)/$$proj/mca/common" \( -name 'lib*mca_common_*.dylib' -o -name 'lib*mca_common_*.so' -o -name 'lib*mca_common_*.so.*' \) 2>/dev/null | \
+	  while read lib; do base=`basename "$$lib"`; test -e "$$libs/$$base" || ln -s "$$lib" "$$libs/$$base" 2>/dev/null || true; done; \
+	done
diff --git a/VERSION b/VERSION
index 44eb7329d5d..c82de41b70f 100644
--- a/VERSION
+++ b/VERSION
@@ -20,7 +20,7 @@ minor=1
 release=0
 
 # MPI Standard Compliance Level
-mpi_standard_version=3
+mpi_standard_version=4
 mpi_standard_subversion=1
 
 # OMPI required dependency versions.
@@ -101,7 +101,6 @@ libmpi_usempi_tkr_so_version=0:0:0
 libmpi_usempi_ignore_tkr_so_version=0:0:0
 libmpi_usempif08_so_version=0:0:0
 libopen_pal_so_version=0:0:0
-libmpi_java_so_version=0:0:0
 liboshmem_so_version=0:0:0
 libompitrace_so_version=0:0:0
 
diff --git a/config/Makefile.am b/config/Makefile.am
index 4af3a33f87c..d4ba7b16c33 100644
--- a/config/Makefile.am
+++ b/config/Makefile.am
@@ -41,7 +41,6 @@ EXTRA_DIST = \
         opal_get_version.m4sh \
         ltmain_nag_pthread.diff \
         ltmain_pgi_tp.diff \
-        opal_mca_priority_sort.pl \
         find_common_syms \
         getdate.sh \
         from-savannah/upstream-config.guess \
diff --git a/config/c_weak_aliases.m4 b/config/c_weak_aliases.m4
new file mode 100644
index 00000000000..2a51c11b8a1
--- /dev/null
+++ b/config/c_weak_aliases.m4
@@ -0,0 +1,135 @@
+dnl -*- shell-script -*-
+dnl
+dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+dnl                         University Research and Technology
+dnl                         Corporation.  All rights reserved.
+dnl Copyright (c) 2004-2005 The University of Tennessee and The University
+dnl                         of Tennessee Research Foundation.  All rights
+dnl                         reserved.
+dnl Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+dnl                         University of Stuttgart.  All rights reserved.
+dnl Copyright (c) 2004-2005 The Regents of the University of California.
+dnl                         All rights reserved.
+dnl Copyright (c) 2014      Research Organization for Information Science
+dnl                         and Technology (RIST). All rights reserved.
+dnl Copyright (c) 2014 Cisco Systems, Inc.  All rights reserved.
+dnl Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+dnl $COPYRIGHT$
+dnl
+dnl Additional copyrights may follow
+dnl
+dnl $HEADER$
+dnl
+
+# _OPAL_C_WEAK_ALIASES(action_if_found, [action_if_not_found])
+# ------------------------------------------------------------
+AC_DEFUN([_OPAL_C_WEAK_ALIASES],[
+    # need two files because icc will incorrectly not create the
+    # symbols if they are not used in the object file in which they
+    # are defined.  Blah!
+    # To get to compile with icc, have them in a separate header.
+    cat > conftest_weak.h <<EOF
+int real(int i);
+int fake(int i);
+EOF
+
+    cat > conftest_weak.c <<EOF
+#include "conftest_weak.h"
+#pragma weak fake = real
+int real(int i) { return i; }
+EOF
+
+    cat > conftest.c <<EOF
+#include "conftest_weak.h"
+int main() { return fake(3); }
+EOF
+
+# Try the compile
+OPAL_LOG_COMMAND(
+    [$CC $CFLAGS  -c conftest_weak.c],
+    [OPAL_LOG_COMMAND(
+        [$CC $CFLAGS  conftest.c conftest_weak.o -o conftest $LDFLAGS $LIBS],
+        [opal_c_weak_aliases_happy=1],
+        [opal_c_weak_aliases_happy=0])],
+    [opal_c_weak_aliases_happy=0])
+
+    AS_IF([test "$opal_c_weak_aliases_happy" = "1"], [$1], [$2])
+
+    unset opal_c_weak_aliases_happy
+    rm -f conftest_weak.h conftest_weak.c conftest.c conftest
+])
+
+
+# OPAL_C_WEAK_ALIASES()
+# ---------------------
+# sets OPAL_C_HAVE_WEAK_ALIASES=1 if C compiler has support for weak aliases
+AC_DEFUN([OPAL_C_WEAK_ALIASES],[
+    AC_CACHE_CHECK([for weak alias support],
+                   [opal_cv_c_weak_aliases],
+                   [_OPAL_C_WEAK_ALIASES([opal_cv_c_weak_aliases="yes"],
+                                         [opal_cv_c_weak_aliases="no"])])
+
+    AS_IF([test "$opal_cv_c_weak_aliases" = "yes"],
+          [OPAL_C_HAVE_WEAK_ALIASES=1], [OPAL_C_HAVE_WEAK_ALIASES=0])
+]) dnl
+
+########################################################################
+
+# _OPAL_C_MACRO_WEAK_ALIASES(action_if_found, [action_if_not_found])
+# ------------------------------------------------------------
+AC_DEFUN([_OPAL_C_MACRO_WEAK_ALIASES],[
+    # need two files because icc will incorrectly not create the
+    # symbols if they are not used in the object file in which they
+    # are defined.  Blah!
+    # To get to compile with icc, have them in a separate header.
+    cat > conftest_weak.h <<EOF
+int real(int i);
+int fake1(int i);
+int fake2(int i);
+
+#define GENERATE_WEAK_PRAGMA(x) _Pragma(#x)
+#define GENERATE_TWO_WEAK_PRAGMAS(real, fake) \
+    GENERATE_WEAK_PRAGMA(weak fake##1 = real) \
+    GENERATE_WEAK_PRAGMA(weak fake##2 = real)
+EOF
+
+    cat > conftest_weak.c <<EOF
+#include "conftest_weak.h"
+GENERATE_TWO_WEAK_PRAGMAS(real, fake)
+int real(int i) { return i; }
+EOF
+
+    cat > conftest.c <<EOF
+#include "conftest_weak.h"
+int main() { return fake1(3) + fake2(3); }
+EOF
+
+# Try the compile
+OPAL_LOG_COMMAND(
+    [$CC $CFLAGS  -c conftest_weak.c],
+    [OPAL_LOG_COMMAND(
+        [$CC $CFLAGS  conftest.c conftest_weak.o -o conftest $LDFLAGS $LIBS],
+        [opal_c_macro_weak_aliases_happy=1],
+        [opal_c_macro_weak_aliases_happy=0])],
+    [opal_c_macro_weak_aliases_happy=0])
+
+    AS_IF([test "$opal_c_macro_weak_aliases_happy" = "1"], [$1], [$2])
+
+    unset opal_c_macro_weak_aliases_happy
+    rm -f conftest_weak.h conftest_weak.c conftest.c conftest
+])
+
+# OPAL_C_MACRO_WEAK_ALIASES
+# ---------------------
+# Sets OPAL_C_HAVE_MACRO_WEAK_ALIASES=1 if C compiler has support for weak
+# aliases
+AC_DEFUN([OPAL_C_MACRO_WEAK_ALIASES],[
+    AC_CACHE_CHECK([for macro weak alias support],
+                   [opal_cv_c_macro_weak_aliases],
+                   [_OPAL_C_MACRO_WEAK_ALIASES([opal_cv_c_macro_weak_aliases="yes"],
+                                               [opal_cv_c_macro_weak_aliases="no"])])
+
+    AS_IF([test "$opal_cv_c_macro_weak_aliases" = "yes"],
+          [OPAL_C_HAVE_MACRO_WEAK_ALIASES=1],
+          [OPAL_C_HAVE_MACRO_WEAK_ALIASES=0])
+]) dnl
diff --git a/config/c_weak_symbols.m4 b/config/c_weak_symbols.m4
index 387d0eeaed7..84818b70f2f 100644
--- a/config/c_weak_symbols.m4
+++ b/config/c_weak_symbols.m4
@@ -13,6 +13,7 @@ dnl                         All rights reserved.
 dnl Copyright (c) 2014      Research Organization for Information Science
 dnl                         and Technology (RIST). All rights reserved.
 dnl Copyright (c) 2014 Cisco Systems, Inc.  All rights reserved.
+dnl Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 dnl $COPYRIGHT$
 dnl
 dnl Additional copyrights may follow
@@ -22,25 +23,34 @@ dnl
 
 # _OPAL_C_WEAK_SYMBOLS(action_if_found, [action_if_not_found])
 # ------------------------------------------------------------
+# This tests for support of plain weak symbols: a symbol that is
+# *defined* weakly (via "#pragma weak") can be overridden by a strong
+# definition of the same symbol without provoking a duplicate-symbol
+# link error.  This is a distinct linker feature from weak symbol
+# *aliases* (see OPAL_C_WEAK_ALIASES); notably, macOS / Mach-O supports
+# weak symbols but does *not* support weak aliases.
 AC_DEFUN([_OPAL_C_WEAK_SYMBOLS],[
-    # need two files because icc will incorrectly not create the
-    # symbols if they are not used in the object file in which they
-    # are defined.  Blah!
-    # To get to compile with icc, have them in a separate header.
+    # Use two files because icc will incorrectly not create the symbols
+    # if they are not used in the object file in which they are defined.
+    # To get it to compile with icc, put the declaration in a separate
+    # header.
     cat > conftest_weak.h <<EOF
 int real(int i);
-int fake(int i);
 EOF
 
+    # conftest_weak.c provides a *weak* definition of real().
     cat > conftest_weak.c <<EOF
 #include "conftest_weak.h"
-#pragma weak fake = real
-int real(int i) { return i; }
+#pragma weak real
+int real(int i) { return i + 42; }
 EOF
 
+    # conftest.c provides a *strong* definition of real() that must
+    # override the weak one at link time.
     cat > conftest.c <<EOF
 #include "conftest_weak.h"
-int main() { return fake(3); }
+int real(int i) { return i; }
+int main() { return real(3); }
 EOF
 
 # Try the compile
@@ -61,7 +71,8 @@ OPAL_LOG_COMMAND(
 
 # OPAL_C_WEAK_SYMBOLS()
 # ---------------------
-# sets OPAL_C_HAVE_WEAK_SYMBOLS=1 if C compiler has support for weak symbols
+# sets OPAL_C_HAVE_WEAK_SYMBOLS=1 if C compiler has support for weak
+# symbols
 AC_DEFUN([OPAL_C_WEAK_SYMBOLS],[
     AC_CACHE_CHECK([for weak symbol support],
                    [opal_cv_c_weak_symbols],
@@ -70,65 +81,6 @@ AC_DEFUN([OPAL_C_WEAK_SYMBOLS],[
 
     AS_IF([test "$opal_cv_c_weak_symbols" = "yes"],
           [OPAL_C_HAVE_WEAK_SYMBOLS=1], [OPAL_C_HAVE_WEAK_SYMBOLS=0])
-]) dnl
-
-########################################################################
-
-# _OPAL_C_MACRO_WEAK_SYMBOLS(action_if_found, [action_if_not_found])
-# ------------------------------------------------------------
-AC_DEFUN([_OPAL_C_MACRO_WEAK_SYMBOLS],[
-    # need two files because icc will incorrectly not create the
-    # symbols if they are not used in the object file in which they
-    # are defined.  Blah!
-    # To get to compile with icc, have them in a separate header.
-    cat > conftest_weak.h <<EOF
-int real(int i);
-int fake1(int i);
-int fake2(int i);
-
-#define GENERATE_WEAK_PRAGMA(x) _Pragma(#x)
-#define GENERATE_TWO_WEAK_PRAGMAS(real, fake) \
-    GENERATE_WEAK_PRAGMA(weak fake##1 = real) \
-    GENERATE_WEAK_PRAGMA(weak fake##2 = real)
-EOF
-
-    cat > conftest_weak.c <<EOF
-#include "conftest_weak.h"
-GENERATE_TWO_WEAK_PRAGMAS(real, fake)
-int real(int i) { return i; }
-EOF
-
-    cat > conftest.c <<EOF
-#include "conftest_weak.h"
-int main() { return fake1(3) + fake2(3); }
-EOF
-
-# Try the compile
-OPAL_LOG_COMMAND(
-    [$CC $CFLAGS  -c conftest_weak.c],
-    [OPAL_LOG_COMMAND(
-        [$CC $CFLAGS  conftest.c conftest_weak.o -o conftest $LDFLAGS $LIBS],
-        [opal_c_macro_weak_symbols_happy=1],
-        [opal_c_macro_weak_symbols_happy=0])],
-    [opal_c_macro_weak_symbols_happy=0])
-
-    AS_IF([test "$opal_c_macro_weak_symbols_happy" = "1"], [$1], [$2])
-
-    unset opal_c_macro_weak_symbols_happy
-    rm -f conftest_weak.h conftest_weak.c conftest.c conftest
-])
-
-# OPAL_C_MACRO_WEAK_SYMBOLS
-# ---------------------
-# Sets OPAL_C_HAVE_MACRO_WEAK_SYMBOLS=1 if C compiler has support for weak
-# symbols
-AC_DEFUN([OPAL_C_MACRO_WEAK_SYMBOLS],[
-    AC_CACHE_CHECK([for macro weak symbol support],
-                   [opal_cv_c_macro_weak_symbols],
-                   [_OPAL_C_MACRO_WEAK_SYMBOLS([opal_cv_c_macro_weak_symbols="yes"],
-                                               [opal_cv_c_macro_weak_symbols="no"])])
-
-    AS_IF([test "$opal_cv_c_macro_weak_symbols" = "yes"],
-          [OPAL_C_HAVE_MACRO_WEAK_SYMBOLS=1],
-          [OPAL_C_HAVE_MACRO_WEAK_SYMBOLS=0])
+    AC_DEFINE_UNQUOTED([OPAL_HAVE_WEAK_SYMBOLS], [$OPAL_C_HAVE_WEAK_SYMBOLS],
+        [Whether the C compiler supports plain weak symbols or not])
 ]) dnl
diff --git a/config/ltmain_flang_darwin.diff b/config/ltmain_flang_darwin.diff
index 02dc81d988a..138b5f3ff6a 100644
--- a/config/ltmain_flang_darwin.diff
+++ b/config/ltmain_flang_darwin.diff
@@ -1,13 +1,14 @@
 --- config/ltmain.sh
 +++ config/ltmain.sh
-@@ -9024,7 +9024,14 @@
+@@ -9024,7 +9024,15 @@
 	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
 	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
 	else
 -	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 +	  case $host in
 +	    *-*-darwin*)
-+	      case $CC in
++	      func_cc_basename "$CC"
++	      case $func_cc_basename_result in
 +		flang*) compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -Wl,-framework,\1%g'`;;
 +		*) compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`;;
 +	      esac;;
@@ -16,7 +17,7 @@
 	fi
        fi
        dependency_libs=$newdependency_libs
-@@ -9369,7 +9376,7 @@
+@@ -9369,7 +9377,7 @@
            # On Darwin other compilers
            func_cc_basename $CC
            case $func_cc_basename_result in
@@ -25,12 +26,13 @@
                    verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
                    ;;
                *)
-@@ -9869,7 +9876,10 @@
+@@ -9869,7 +9877,11 @@
        # Time to change all our "foo.ltframework" stuff back to "-framework foo"
        case $host in
 	  *-*-darwin*)
 -	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
-+	  case $CC in
++	  func_cc_basename "$CC"
++	  case $func_cc_basename_result in
 +	    flang*) newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -Wl,-framework,\1%g'`;;
 +	    *) newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`;;
 +	  esac
diff --git a/config/ompi_check_psm2.m4 b/config/ompi_check_psm2.m4
index 2f5322d2b9e..6ff0e88e6e9 100644
--- a/config/ompi_check_psm2.m4
+++ b/config/ompi_check_psm2.m4
@@ -20,6 +20,7 @@
 #  Copyright (c) 2021     Triad National Security, LLC. All rights
 #                         reserved.
 # Copyright (c) 2022      Amazon.com, Inc. or its affiliates.  All Rights reserved.
+# Copyright (c) 2025      Cornelis Networks, Inc. All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -37,10 +38,10 @@ AC_DEFUN([OMPI_CHECK_PSM2],[
 
     AC_ARG_WITH([psm2],
                 [AS_HELP_STRING([--with-psm2(=DIR)],
-                    [Build PSM2 (Intel PSM2) support, optionally adding DIR/include, DIR/lib, and DIR/lib64 to the search path for headers and libraries])])
+                    [Build PSM2 (Cornelis PSM2) support, optionally adding DIR/include, DIR/lib, and DIR/lib64 to the search path for headers and libraries])])
     AC_ARG_WITH([psm2-libdir],
                 [AS_HELP_STRING([--with-psm2-libdir=DIR],
-                    [Search for PSM (Intel PSM2) libraries in DIR])])
+                    [Search for PSM (Cornelis PSM2) libraries in DIR])])
 
     AC_ARG_ENABLE([psm2-version-check],
                   [AS_HELP_STRING([--disable-psm2-version-check],
@@ -81,7 +82,7 @@ AC_DEFUN([OMPI_CHECK_PSM2],[
 
     CPPFLAGS="${opal_psm2_CPPFLAGS_save}"
 
-    OPAL_SUMMARY_ADD([Transports], [Intel Omnipath (PSM2)], [], [${$1_SUMMARY}])
+    OPAL_SUMMARY_ADD([Transports], [Cornelis Omnipath (PSM2)], [], [${$1_SUMMARY}])
 
     AS_IF([test "$ompi_check_psm2_happy" = "yes"],
           [$2],
diff --git a/config/ompi_check_ubcl.m4 b/config/ompi_check_ubcl.m4
index 0957a4fe2ed..0b6bf689458 100644
--- a/config/ompi_check_ubcl.m4
+++ b/config/ompi_check_ubcl.m4
@@ -8,7 +8,7 @@
 #                         reserved.
 # Copyright (c) 2016 Cisco Systems, Inc.  All rights reserved.
 # Copyright (c) 2022      Amazon.com, Inc. or its affiliates.  All Rights reserved.
-# Copyright (c) 2024-2025 Bull S.A.S.  All rights reserved.
+# Copyright (c) 2024-2026 Bull S.A.S.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -32,6 +32,18 @@ AC_DEFUN([OMPI_CHECK_UBCL],[
 
     # UBCL is dlopen'd to avoid direct link to libubcl.so.
     # OAC_CHECK_PACKAGE would add this explicit link, so it cannot be used.
+
+    # No option means no dso and with-ubcl=""
+    AS_IF([test "$with_ubcl" = "yes" || test "x$with_ubcl" = "x"],
+          [AC_MSG_NOTICE([Unspecified UBCL path])
+           guessed_path="`find /opt/ubcl -name ubcl_api.h 2>/dev/null \
+                          | sort | tail -n1                          \
+                          | cut -d "/" -f1-4`"
+           AS_IF([test "x$guessed_path" != "x"],
+                 [with_ubcl=$guessed_path
+                 AC_MSG_NOTICE([Guessed that UBCL is $guessed_path])])
+           ])
+
     # OPAL_CHECK_WITHDIR prints an error if the given path is invalid
     OPAL_CHECK_WITHDIR([ubcl], [$with_ubcl], [include/ubcl_api.h])
 
@@ -43,7 +55,13 @@ AC_DEFUN([OMPI_CHECK_UBCL],[
 
           [ompi_check_ubcl_happy="yes"
            $1_CPPFLAGS="${$1_CPPFLAGS} -I$with_ubcl/include/"
-           AC_MSG_NOTICE([$1_CPPFLAGS is set to: ${$1_CPPFLAGS}])])
+           AC_MSG_NOTICE([$1_CPPFLAGS is set to: ${$1_CPPFLAGS}])
+           # Let define UBCL linking flags even if they will be ignored afterwards
+           # as ubcl components are very likely compiled in dynamic mode
+           # See ompi/mca/common/ubcl/configure.m4 comment explaining why UBCL linking
+           # flags are removed only in dynamic mode
+           $1_LDFLAGS="${$1_LDFLAGS} -lubcl -L$with_ubcl/lib/"
+           AC_MSG_NOTICE([$1_LDFLAGS is set to: ${$1_LDFLAGS}])])
 
 
     OPAL_SUMMARY_ADD([Transports],[UBCL],[],[$ompi_check_ubcl_happy])
diff --git a/config/ompi_config_files.m4 b/config/ompi_config_files.m4
index 21d1e3eb791..560d602ecf1 100644
--- a/config/ompi_config_files.m4
+++ b/config/ompi_config_files.m4
@@ -8,6 +8,7 @@
 # Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
 # Copyright (c) 2021      Amazon.com, Inc. or its affiliates.  All Rights
 #                         reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -26,6 +27,14 @@ AC_DEFUN([OMPI_CONFIG_FILES],[
         ompi/datatype/Makefile
         ompi/debuggers/Makefile
 
+        ompi/test/Makefile
+        ompi/test/t/Makefile
+        ompi/test/file/Makefile
+        ompi/test/datatype/Makefile
+        ompi/test/general/Makefile
+        ompi/test/monitoring/Makefile
+        ompi/test/spc/Makefile
+
         ompi/mpi/c/Makefile
         ompi/mpi/fortran/base/Makefile
         ompi/mpi/fortran/mpif-h/Makefile
@@ -54,7 +63,6 @@ AC_DEFUN([OMPI_CONFIG_FILES],[
         ompi/tools/wrappers/ompi-c.pc
         ompi/tools/wrappers/ompi-cxx.pc
         ompi/tools/wrappers/ompi-fort.pc
-        ompi/tools/wrappers/mpijavac.pl
         ompi/tools/mpisync/Makefile
         ompi/tools/mpirun/Makefile
     ])
diff --git a/config/ompi_fortran_check.m4 b/config/ompi_fortran_check.m4
index 7fd2a790353..7646a7e6f06 100644
--- a/config/ompi_fortran_check.m4
+++ b/config/ompi_fortran_check.m4
@@ -161,9 +161,12 @@ AC_DEFUN([OMPI_FORTRAN_CHECK], [
 
     # We always need these defines -- even if we don't have a given
     # type, there are some places in the code where we have to have
-    # *something*.  Note that the bpatsubst's are the same as used
-    # above (see comment above), but we added a translit to make them
-    # uppercase.
+    # *something*.  We strip '*' from the type name (e.g. INTEGER*4 ->
+    # INTEGER4) and then run AS_TR_SH to map any remaining non-symbol
+    # characters to '_'.  AS_TR_SH is locale-safe; an earlier version
+    # used m4_bpatsubst with a regex character class, which mis-handled
+    # locales whose collation defines digraphs (e.g. cs_CZ.UTF-8 treats
+    # 'ch' as one element and would mangle "char" -> "_ar").
 
     # If we got a pretty name, use that as the basis.  If not, use the
     # first part of the provided fortran type (e.g.,
@@ -174,38 +177,38 @@ AC_DEFUN([OMPI_FORTRAN_CHECK], [
     # the result of the BLUm4E in a shell variable and use that in
     # AC_DEFINE_UNQUOTED), autoheader won't put them in the
     # AC_CONFIG_HEADER (or AM_CONFIG_HEADER, in our case).
-    AC_DEFINE_UNQUOTED([OMPI_HAVE_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
+    AC_DEFINE_UNQUOTED([OMPI_HAVE_FORTRAN_]m4_translit(AS_TR_SH(m4_bpatsubst([$1], [*], [])), [a-z], [A-Z]),
                        [$ofc_have_type],
                        [Whether we have Fortran $1 or not])
-    AC_DEFINE_UNQUOTED([OMPI_SIZEOF_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
+    AC_DEFINE_UNQUOTED([OMPI_SIZEOF_FORTRAN_]m4_translit(AS_TR_SH(m4_bpatsubst([$1], [*], [])), [a-z], [A-Z]),
                        [$ofc_type_size],
                        [Size of Fortran $1])
-    AC_DEFINE_UNQUOTED([OMPI_ALIGNMENT_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
+    AC_DEFINE_UNQUOTED([OMPI_ALIGNMENT_FORTRAN_]m4_translit(AS_TR_SH(m4_bpatsubst([$1], [*], [])), [a-z], [A-Z]),
                        [$ofc_type_alignment],
                        [Alignment of Fortran $1])
-    AC_DEFINE_UNQUOTED([OMPI_KIND_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]),
+    AC_DEFINE_UNQUOTED([OMPI_KIND_FORTRAN_]m4_translit(AS_TR_SH(m4_bpatsubst([$1], [*], [])), [a-z], [A-Z]),
                        [$ofc_type_kind],
                        [Fortran KIND number for $1])
     if test "$3" != "" && test "$ofc_define_type" = "yes"; then
-        AC_DEFINE_UNQUOTED([ompi_fortran_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [A-Z], [a-z])[_t],
+        AC_DEFINE_UNQUOTED([ompi_fortran_]m4_translit(AS_TR_SH(m4_bpatsubst([$1], [*], [])), [A-Z], [a-z])[_t],
                            [$ofc_c_type],
                            [C type corresponding to Fortran $1])
     fi
 
     # Save some in shell variables for later use (e.g., need
     # OMPI_SIZEOF_FORTRAN_INTEGER in OMPI_FORTRAN_GET_HANDLE_MAX)
-    [OMPI_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[_C_TYPE=$ofc_c_type]
-    [OMPI_KIND_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_kind]
-    [OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_have_type]
-    [OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_size]
-    [OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_])[=$ofc_type_alignment]
+    [OMPI_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], []))[_C_TYPE=$ofc_c_type]
+    [OMPI_KIND_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], []))[=$ofc_type_kind]
+    [OMPI_HAVE_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], []))[=$ofc_have_type]
+    [OMPI_SIZEOF_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], []))[=$ofc_type_size]
+    [OMPI_ALIGNMENT_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], []))[=$ofc_type_alignment]
 
     # Wow, this is sick.  But it works!  :-)
-    AC_SUBST([OMPI_HAVE_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
-    AC_SUBST([OMPI_KIND_FORTRAN_]m4_translit(m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]), [a-z], [A-Z]))
-    AC_SUBST([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
-    AC_SUBST([OMPI_SIZEOF_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
-    AC_SUBST([OMPI_ALIGNMENT_FORTRAN_]m4_bpatsubst(m4_bpatsubst([$1], [*], []), [[^a-zA-Z0-9_]], [_]))
+    AC_SUBST([OMPI_HAVE_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], [])))
+    AC_SUBST([OMPI_KIND_FORTRAN_]m4_translit(AS_TR_SH(m4_bpatsubst([$1], [*], [])), [a-z], [A-Z]))
+    AC_SUBST([OMPI_SIZEOF_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], [])))
+    AC_SUBST([OMPI_SIZEOF_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], [])))
+    AC_SUBST([OMPI_ALIGNMENT_FORTRAN_]AS_TR_SH(m4_bpatsubst([$1], [*], [])))
 
     # Clean up
     OPAL_VAR_SCOPE_POP
diff --git a/config/ompi_setup_java.m4 b/config/ompi_setup_java.m4
deleted file mode 100644
index 596df8be9b7..00000000000
--- a/config/ompi_setup_java.m4
+++ /dev/null
@@ -1,234 +0,0 @@
-dnl -*- shell-script -*-
-dnl
-dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
-dnl                         University Research and Technology
-dnl                         Corporation.  All rights reserved.
-dnl Copyright (c) 2004-2006 The University of Tennessee and The University
-dnl                         of Tennessee Research Foundation.  All rights
-dnl                         reserved.
-dnl Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
-dnl                         University of Stuttgart.  All rights reserved.
-dnl Copyright (c) 2004-2006 The Regents of the University of California.
-dnl                         All rights reserved.
-dnl Copyright (c) 2006-2012 Los Alamos National Security, LLC.  All rights
-dnl                         reserved.
-dnl Copyright (c) 2007-2012 Oracle and/or its affiliates.  All rights reserved.
-dnl Copyright (c) 2008-2018 Cisco Systems, Inc.  All rights reserved
-dnl Copyright (c) 2013      Intel, Inc.  All rights reserved.
-dnl Copyright (c) 2015-2018 Research Organization for Information Science
-dnl                         and Technology (RIST). All rights reserved.
-dnl Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
-dnl Copyright (c) 2025      Nanook Consulting  All rights reserved.
-dnl $COPYRIGHT$
-dnl
-dnl Additional copyrights may follow
-dnl
-dnl $HEADER$
-dnl
-
-dnl _OMPI_SETUP_JAVA()
-dnl ----------------
-dnl Invoked by OMPI_SETUP_JAVA only if --enable-mpi-java was specified.
-AC_DEFUN([_OMPI_SETUP_JAVA],[
-    OPAL_VAR_SCOPE_PUSH([ompi_java_bad ompi_java_found ompi_java_dir ompi_java_jnih ompi_java_PATH_save ompi_java_CPPFLAGS_save])
-
-    # Check for bozo case: ensure a directory was specified
-    AS_IF([test "$with_jdk_dir" = "yes" || test "$with_jdk_dir" = "no"],
-          [AC_MSG_WARN([Must specify a directory name for --with-jdk-dir])
-           AC_MSG_ERROR([Cannot continue])])
-    AS_IF([test "$with_jdk_bindir" = "yes" || test "$with_jdk_bindir" = "no"],
-          [AC_MSG_WARN([Must specify a directory name for --with-jdk-bindir])
-           AC_MSG_ERROR([Cannot continue])])
-    AS_IF([test "$with_jdk_headers" = "yes" || test "$with_jdk_headers" = "no"],
-          [AC_MSG_WARN([Must specify a directory name for --with-jdk-headers])
-           AC_MSG_ERROR([Cannot continue])])
-
-    # Check for bozo case: either specify --with-jdk-dir or
-    # (--with-jdk-bindir, --with-jdk-headers) -- not both.
-    ompi_java_bad=0
-    AS_IF([test -n "$with_jdk_dir" && \
-           (test -n "$with_jdk_bindir" || test -n "$with_jdk_headers")],
-          [ompi_java_bad=1])
-    AS_IF([(test -z "$with_jdk_bindir" && test -n "$with_jdk_headers") || \
-           (test -n "$with_jdk_bindir" && test -z "$with_jdk_headers")],
-          [ompi_java_bad=1])
-    AS_IF([test $ompi_java_bad -eq 1],
-          [AC_MSG_WARN([Either specify --with-jdk-dir or both of (--with-jdk_bindir, --with-jdk-headers) -- not both.])
-           AC_MSG_ERROR([Cannot continue])])
-
-    AS_IF([test -n "$with_jdk_dir"],
-          [with_jdk_bindir=$with_jdk_dir/bin
-           with_jdk_headers=$with_jdk_dir/include])
-
-    ##################################################################
-    # with_jdk_dir can now be ignored; with_jdk_bindir and
-    # with_jdk_headers will be either empty or have valid values.
-    ##################################################################
-
-    # Some java installations are in obscure places.  So let's
-    # hard-code a few of the common ones so that users don't have to
-    # specify --with-java-<foo>=LONG_ANNOYING_DIRECTORY.
-    AS_IF([test -z "$with_jdk_bindir"],
-          [ # OS X/macOS
-           ompi_java_found=0
-           # The following logic was deliberately decided upon in
-           # https://github.com/open-mpi/ompi/pull/5015 specifically
-           # to prevent this script and the rest of Open MPI's build
-           # system from getting confused by the somewhat unorthodox
-           # Java toolchain layout present on OS X/macOS systems,
-           # described in depth by
-           # https://github.com/open-mpi/ompi/pull/5015#issuecomment-379324639,
-           # and mishandling OS X/macOS Java toolchain path detection
-           # as a result.
-           AS_IF([test -x /usr/libexec/java_home],
-                 [ompi_java_dir=`/usr/libexec/java_home`],
-                 [ompi_java_dir=/System/Library/Frameworks/JavaVM.framework/Versions/Current])
-           AC_MSG_CHECKING([for Java in OS X/macOS locations])
-           AS_IF([test -d "$ompi_java_dir"],
-                 [AC_MSG_RESULT([found ($ompi_java_dir)])
-                  ompi_java_found=1
-                  if test -d "$ompi_java_dir/Headers" && test -d "$ompi_java_dir/Commands"; then
-                      with_jdk_headers=$ompi_java_dir/Headers
-                      with_jdk_bindir=$ompi_java_dir/Commands
-                  elif test -d "$ompi_java_dir/include" && test -d "$ompi_java_dir/bin"; then
-                      with_jdk_headers=$ompi_java_dir/include
-                      with_jdk_bindir=$ompi_java_dir/bin
-                  else
-                      AC_MSG_WARN([No recognized OS X/macOS JDK directory structure found under $ompi_java_dir])
-                      ompi_java_found=0
-                  fi],
-                 [AC_MSG_RESULT([not found])])
-
-           if test "$ompi_java_found" = "0"; then
-               # Various Linux
-               if test -z "$JAVA_HOME"; then
-                   ompi_java_dir='/usr/lib/jvm/java-*-openjdk*/include/'
-               else
-                   ompi_java_dir=$JAVA_HOME/include
-               fi
-               ompi_java_jnih=`ls $ompi_java_dir/jni.h 2>/dev/null | head -n 1`
-               AC_MSG_CHECKING([for Java in Linux locations])
-               AS_IF([test -r "$ompi_java_jnih"],
-                     [with_jdk_headers=`dirname $ompi_java_jnih`
-                      OPAL_WHICH([javac], [with_jdk_bindir])
-                      AS_IF([test -n "$with_jdk_bindir"],
-                            [AC_MSG_RESULT([found ($with_jdk_headers)])
-                             ompi_java_found=1
-                             with_jdk_bindir=`dirname $with_jdk_bindir`],
-                            [with_jdk_headers=])],
-                     [ompi_java_dir='/usr/lib/jvm/default-java/include/'
-                      ompi_java_jnih=`ls $ompi_java_dir/jni.h 2>/dev/null | head -n 1`
-                      AS_IF([test -r "$ompi_java_jnih"],
-                            [with_jdk_headers=`dirname $ompi_java_jnih`
-                             OPAL_WHICH([javac], [with_jdk_bindir])
-                             AS_IF([test -n "$with_jdk_bindir"],
-                                   [AC_MSG_RESULT([found ($with_jdk_headers)])
-                                    ompi_java_found=1
-                                    with_jdk_bindir=`dirname $with_jdk_bindir`],
-                                   [with_jdk_headers=])],
-                             [AC_MSG_RESULT([not found])])])
-           fi
-
-          ],
-          [ompi_java_found=1])
-
-    if test "$ompi_java_found" = "1"; then
-        OPAL_CHECK_WITHDIR([jdk-bindir], [$with_jdk_bindir], [javac])
-        OPAL_CHECK_WITHDIR([jdk-headers], [$with_jdk_headers], [jni.h])
-
-        # Look for various Java-related programs
-        ompi_java_happy=no
-        ompi_java_PATH_save=$PATH
-        AS_IF([test -n "$with_jdk_bindir" && test "$with_jdk_bindir" != "yes" && test "$with_jdk_bindir" != "no"],
-              [PATH="$with_jdk_bindir:$PATH"])
-        AC_PATH_PROG(JAVAC, javac)
-        AC_PATH_PROG(JAR, jar)
-        AC_PATH_PROG(JAVADOC, javadoc)
-        AC_PATH_PROG(JAVAH, javah)
-        PATH=$ompi_java_PATH_save
-
-        # Check to see if we have all 3 programs.
-        AS_IF([test -z "$JAVAC" || test -z "$JAR" || test -z "$JAVADOC"],
-              [ompi_java_happy=no],
-              [ompi_java_happy=yes])
-
-        # Look for jni.h
-        AS_IF([test "$ompi_java_happy" = "yes"],
-              [ompi_java_CPPFLAGS_save=$CPPFLAGS
-               # silence a stupid Mac warning
-               CPPFLAGS="$CPPFLAGS -DTARGET_RT_MAC_CFM=0"
-               AC_MSG_CHECKING([javac -h])
-               cat > Conftest.java << EOF
-public final class Conftest {
-    public native void conftest();
-}
-EOF
-               AS_IF([$JAVAC -d . -h . Conftest.java > /dev/null 2>&1],
-                     [AC_MSG_RESULT([yes])],
-                     [AC_MSG_RESULT([no])
-                      AS_IF([test -n "$JAVAH"],
-                            [ompi_javah_happy=yes],
-                            [ompi_java_happy=no])])
-               rm -f Conftest.java Conftest.class Conftest.h
-
-               AS_IF([test -n "$with_jdk_headers" && test "$with_jdk_headers" != "yes" && test "$with_jdk_headers" != "no"],
-                     [OMPI_JDK_CPPFLAGS="-I$with_jdk_headers"
-                      # Some flavors of JDK also require -I<blah>/linux.
-                      # See if that's there, and if so, add a -I for that,
-                      # too.  Ugh.
-                      AS_IF([test -d "$with_jdk_headers/linux"],
-                            [OMPI_JDK_CPPFLAGS="$OMPI_JDK_CPPFLAGS -I$with_jdk_headers/linux"])
-                      # Darwin JDK also require -I<blah>/darwin.
-                      # See if that's there, and if so, add a -I for that,
-                      # too.  Ugh.
-                      AS_IF([test -d "$with_jdk_headers/darwin"],
-                            [OMPI_JDK_CPPFLAGS="$OMPI_JDK_CPPFLAGS -I$with_jdk_headers/darwin"])
-
-                      CPPFLAGS="$CPPFLAGS $OMPI_JDK_CPPFLAGS"])
-               AC_CHECK_HEADER([jni.h], [],
-                               [ompi_java_happy=no])
-               CPPFLAGS=$ompi_java_CPPFLAGS_save
-              ])
-    else
-        ompi_java_happy=no
-    fi
-    AC_SUBST(OMPI_JDK_CPPFLAGS)
-
-    # Are we happy?
-    AC_MSG_CHECKING([if Java support available])
-    AS_IF([test "$ompi_java_happy" = "yes"],
-          [AC_MSG_RESULT([yes])],
-          [AC_MSG_RESULT([no])
-           AC_MSG_WARN([Java support requested but not found.])
-           AC_MSG_ERROR([Cannot continue])])
-
-    OPAL_VAR_SCOPE_POP
-])
-
-dnl OMPI_SETUP_JAVA()
-dnl ----------------
-dnl Do everything required to setup the Java compiler.
-AC_DEFUN([OMPI_SETUP_JAVA],[
-    OPAL_VAR_SCOPE_PUSH([ompi_java_happy ompi_javah_happy])
-
-    ompi_java_happy=no
-    ompi_javah_happy=no
-
-    AC_ARG_WITH([jdk-dir],
-                [AS_HELP_STRING([--with-jdk-dir(=DIR)],
-                               [Location of the JDK header directory.  If you use this option, do not specify --with-jdk-bindir or --with-jdk-headers.])])
-    AC_ARG_WITH([jdk-bindir],
-                [AS_HELP_STRING([--with-jdk-bindir(=DIR)],
-                               [Location of the JDK bin directory.  If you use this option, you must also use --with-jdk-headers (and you must NOT use --with-jdk-dir)])])
-    AC_ARG_WITH([jdk-headers],
-                [AS_HELP_STRING([--with-jdk-headers(=DIR)],
-                               [Location of the JDK header directory.  If you use this option, you must also use --with-jdk-bindir (and you must NOT use --with-jdk-dir)])])
-
-    # Only setup the compiler if we were requested to
-    AS_IF([test "$1" = "yes"],
-          [_OMPI_SETUP_JAVA])
-
-    AM_CONDITIONAL(OMPI_HAVE_JAVAH_SUPPORT, test "$ompi_javah_happy" = "yes")
-
-    OPAL_VAR_SCOPE_POP
-])
diff --git a/config/ompi_setup_mpi_fortran.m4 b/config/ompi_setup_mpi_fortran.m4
index c396a2efab6..bdb92ec3124 100644
--- a/config/ompi_setup_mpi_fortran.m4
+++ b/config/ompi_setup_mpi_fortran.m4
@@ -255,6 +255,19 @@ AC_DEFUN([OMPI_SETUP_MPI_FORTRAN],[
     # MPI_Status struct contains 4 C ints and a size_t.
     OMPI_FORTRAN_STATUS_SIZE=0
 
+    # The C-to-Fortran MPI_Status conversion (and other code that passes
+    # MPI values through Fortran default INTEGERs) copies C ints into
+    # INTEGER slots one-for-one.  If the Fortran default INTEGER is
+    # narrower than a C int, the public MPI_Status fields (and other
+    # values) would be silently truncated.  Refuse to build in that case
+    # rather than produce a broken Fortran MPI.  Skip the check when we
+    # are not building any Fortran bindings (e.g., --disable-mpi-fortran,
+    # or no usable Fortran compiler), in which case
+    # OMPI_SIZEOF_FORTRAN_INTEGER is 0.
+    AS_IF([test "$OMPI_SIZEOF_FORTRAN_INTEGER" -gt 0 && \
+           test "$OMPI_SIZEOF_FORTRAN_INTEGER" -lt "$ac_cv_sizeof_int"],
+          [AC_MSG_ERROR([the Fortran default INTEGER ($OMPI_SIZEOF_FORTRAN_INTEGER bytes) is smaller than a C int ($ac_cv_sizeof_int bytes).  Open MPI requires the Fortran default INTEGER to be at least as large as a C int; otherwise values such as the public MPI_Status fields would be truncated when converted between C and Fortran.  Reconfigure with a larger Fortran default INTEGER, or build with --disable-mpi-fortran.])])
+
     # Calculate how many C int's can fit in sizeof(MPI_Status).  Yes,
     # I do mean C ints -- not Fortran INTEGERS.  The reason is because
     # an mpif.h MPI_Status is an array of INTEGERS.  But these
@@ -745,7 +758,7 @@ end type test_mpi_handle],
     #     disabled
     # 1. MPI_<foo> bindings are needed if:
     #   - Profiling is not required
-    #   - Profiling is required but weak symbols are not supported
+    #   - Profiling is required but weak aliases are not supported
     # 2. PMPI_<foo> bindings are needed if profiling is required.
     #
     # Hence we define 2 conditionals which tell us whether each of
@@ -825,13 +838,13 @@ end type test_mpi_handle],
     AC_SUBST(OMPI_F08_SUFFIX)
     AC_SUBST(OMPI_F_SUFFIX)
 
-    # This is used to generate weak symbols (or not) in
+    # This is used to generate weak aliases (or not) in
     # ompi/mpi/fortran/mpif-h/<foo>_f.c, and
     # ompi/mpi/fortran/configure-fortran-output.h.
     AC_SUBST(OMPI_FORTRAN_NEED_WRAPPER_ROUTINES)
     AC_DEFINE_UNQUOTED(OMPI_FORTRAN_NEED_WRAPPER_ROUTINES,
                        [$OMPI_FORTRAN_NEED_WRAPPER_ROUTINES],
-                       [Whether the mpi_f08 implementation is using wrapper routines ("bad" Fortran compiler) or weak symbols ("good" Fortran compiler) for the F08 interface definition implementations])
+                       [Whether the mpi_f08 implementation is using wrapper routines ("bad" Fortran compiler) or weak aliases ("good" Fortran compiler) for the F08 interface definition implementations])
 
     AC_DEFINE_UNQUOTED(OMPI_FORTRAN_F08_HANDLE_SIZE,
                        $OMPI_FORTRAN_F08_HANDLE_SIZE,
diff --git a/config/ompi_setup_mpi_java.m4 b/config/ompi_setup_mpi_java.m4
deleted file mode 100644
index 3f8f76c580f..00000000000
--- a/config/ompi_setup_mpi_java.m4
+++ /dev/null
@@ -1,85 +0,0 @@
-dnl -*- shell-script -*-
-dnl
-dnl Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
-dnl                         University Research and Technology
-dnl                         Corporation.  All rights reserved.
-dnl Copyright (c) 2004-2006 The University of Tennessee and The University
-dnl                         of Tennessee Research Foundation.  All rights
-dnl                         reserved.
-dnl Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
-dnl                         University of Stuttgart.  All rights reserved.
-dnl Copyright (c) 2004-2006 The Regents of the University of California.
-dnl                         All rights reserved.
-dnl Copyright (c) 2006-2012 Los Alamos National Security, LLC.  All rights
-dnl                         reserved.
-dnl Copyright (c) 2007-2012 Oracle and/or its affiliates.  All rights reserved.
-dnl Copyright (c) 2008-2018 Cisco Systems, Inc.  All rights reserved
-dnl Copyright (c) 2015      Research Organization for Information Science
-dnl                         and Technology (RIST). All rights reserved.
-dnl $COPYRIGHT$
-dnl
-dnl Additional copyrights may follow
-dnl
-dnl $HEADER$
-dnl
-
-dnl OMPI_SETUP_JAVA_BINDINGS()
-dnl ----------------
-dnl Do everything required to setup the Java MPI bindings.
-AC_DEFUN([OMPI_SETUP_JAVA_BINDINGS],[
-    opal_show_subtitle "Java MPI bindings"
-
-    AC_ARG_ENABLE([mpi-java],
-        [AS_HELP_STRING([--enable-mpi-java],
-                       [enable Java MPI bindings (default: disabled)])])
-
-    # Find the Java compiler and whatnot.
-    # It knows to do very little if $enable_mpi_java!="yes".
-    OMPI_SETUP_JAVA([$enable_mpi_java])
-
-    # Only build the Java bindings if requested
-    AC_MSG_CHECKING([if want Java bindings])
-    if test "$enable_mpi_java" = "yes"; then
-        AC_MSG_RESULT([yes])
-        WANT_MPI_JAVA_BINDINGS=1
-        AC_MSG_CHECKING([if shared libraries are enabled])
-        AS_IF([test "$enable_shared" != "yes"],
-              [AC_MSG_RESULT([no])
-               AC_MSG_WARN([Java bindings cannot be built without shared libraries])
-               AC_MSG_WARN([Please reconfigure with --enable-shared])
-               AC_MSG_ERROR([Cannot continue])],
-              [AC_MSG_RESULT([yes])])
-
-        # Mac Java requires this file (i.e., some other Java-related
-        # header file needs this file, so we need to check for
-        # it/include it in our sources when compiling on Mac).
-        AC_CHECK_HEADERS([TargetConditionals.h])
-
-        # dladdr and Dl_info are required to build the full path to
-        # libmpi on OS X 10.11 (a.k.a. El Capitan)
-        AC_CHECK_TYPES([Dl_info], [], [], [[#include <dlfcn.h>]])
-    else
-        AC_MSG_RESULT([no])
-        WANT_MPI_JAVA_BINDINGS=0
-    fi
-    AC_DEFINE_UNQUOTED([OMPI_WANT_JAVA_BINDINGS], [$WANT_MPI_JAVA_BINDINGS],
-                       [do we want java mpi bindings])
-    AM_CONDITIONAL(OMPI_WANT_JAVA_BINDINGS, test "$WANT_MPI_JAVA_BINDINGS" = "1")
-
-    # Are we happy?
-    AS_IF([test $WANT_MPI_JAVA_BINDINGS -eq 1],
-          [AC_MSG_WARN([******************************************************])
-           AC_MSG_WARN([*** Java MPI bindings are provided on a provisional])
-           AC_MSG_WARN([*** basis.  They are NOT part of the current or])
-           AC_MSG_WARN([*** proposed MPI standard.  Continued inclusion of])
-           AC_MSG_WARN([*** the Java MPI bindings in Open MPI is contingent])
-           AC_MSG_WARN([*** upon user interest and developer support.])
-           AC_MSG_WARN([******************************************************])
-          ])
-
-    AC_CONFIG_FILES([
-        ompi/mpi/java/Makefile
-        ompi/mpi/java/java/Makefile
-        ompi/mpi/java/c/Makefile
-    ])
-])
diff --git a/config/ompi_setup_mpi_profiling.m4 b/config/ompi_setup_mpi_profiling.m4
index 2fc2ba1f0f7..64158e2e453 100644
--- a/config/ompi_setup_mpi_profiling.m4
+++ b/config/ompi_setup_mpi_profiling.m4
@@ -33,7 +33,7 @@ AC_DEFUN([OMPI_SETUP_MPI_PROFILING],[
     # both) these layers are built.
     # 1. MPI_* bindings are needed if:
     #    - Profiling is not required
-    #    - Profiling is required but weak symbols are not
+    #    - Profiling is required but weak aliases are not
     #      supported
     # 2. PMPI_* bindings are needed if profiling is required.  Hence we
     # define 2 conditionals which tell us whether each of these layers
@@ -45,6 +45,6 @@ AC_DEFUN([OMPI_SETUP_MPI_PROFILING],[
 
     AM_CONDITIONAL(COMPILE_PROFILING_SEPARATELY,
         test "$OMPI_PROFILING_COMPILE_SEPARATELY" = 1)
-    AC_DEFINE_UNQUOTED(OPAL_HAVE_WEAK_SYMBOLS, $OPAL_C_HAVE_WEAK_SYMBOLS,
-        [Whether we have weak symbols or not])
+    AC_DEFINE_UNQUOTED(OPAL_HAVE_WEAK_ALIASES, $OPAL_C_HAVE_WEAK_ALIASES,
+        [Whether we have weak aliases or not])
 ])
diff --git a/config/opal_check_knem.m4 b/config/opal_check_knem.m4
index 65ac21b028e..e0168b33a0d 100644
--- a/config/opal_check_knem.m4
+++ b/config/opal_check_knem.m4
@@ -36,7 +36,7 @@ AC_DEFUN([OPAL_CHECK_KNEM],[
           [opal_check_knem_happy="yes"])
 
     AS_IF([test "${opal_check_knem_happy}" = "yes"],
-          [AS_IF([test -a "${with_knem}" != "yes"],
+          [AS_IF([test -n "${with_knem}" -a "${with_knem}" != "yes"],
                  [$1_CPPFLAGS="-I${with_knem}/include"
                   CPPFLAGS="$CPPFLAGS ${$1_CPPFLAGS}"])
            AC_CHECK_HEADER([knem_io.h], [opal_check_knem_happy="yes"], [opal_check_knem_happy="no"])])
diff --git a/config/opal_configure_options.m4 b/config/opal_configure_options.m4
index 7f5822782fe..a9bbca06135 100644
--- a/config/opal_configure_options.m4
+++ b/config/opal_configure_options.m4
@@ -291,19 +291,29 @@ AC_DEFINE_UNQUOTED([OPAL_ENABLE_PTY_SUPPORT], [$OPAL_ENABLE_PTY_SUPPORT],
 
 
 #
-# Do we want to disable weak symbols for some reason?
+# Do we want to disable weak aliases for some reason?
 #
 
-AC_MSG_CHECKING([if want weak symbol support])
+AC_ARG_ENABLE([weak-aliases],
+    [AS_HELP_STRING([--enable-weak-aliases],
+                   [use weak symbol aliases, if available (default: enabled)])])
+# --enable-weak-symbols is the historical name for this option; keep it
+# as a deprecated synonym for --enable-weak-aliases.
 AC_ARG_ENABLE([weak-symbols],
     [AS_HELP_STRING([--enable-weak-symbols],
-                   [use weak symbols, if available (default: enabled)])])
-if test "$enable_weak_symbols" != "no"; then
+                   [Deprecated synonym for --enable-weak-aliases])])
+AS_IF([test -n "$enable_weak_symbols"],
+      [AC_MSG_WARN([--enable-weak-symbols is deprecated; please use --enable-weak-aliases instead])
+       AS_IF([test -z "$enable_weak_aliases"],
+             [enable_weak_aliases=$enable_weak_symbols])])
+
+AC_MSG_CHECKING([if want weak alias support])
+if test "$enable_weak_aliases" != "no"; then
     AC_MSG_RESULT([yes])
-    WANT_WEAK_SYMBOLS=1
+    WANT_WEAK_ALIASES=1
 else
     AC_MSG_RESULT([no])
-    WANT_WEAK_SYMBOLS=0
+    WANT_WEAK_ALIASES=0
 fi
 
 
diff --git a/config/opal_find_type.m4 b/config/opal_find_type.m4
index bc98dd681c5..0fb12be0aea 100644
--- a/config/opal_find_type.m4
+++ b/config/opal_find_type.m4
@@ -34,7 +34,11 @@ AC_DEFUN([OPAL_FIND_TYPE],[
          AS_IF([test "$oft_target_size" != ""],
              [m4_foreach(oft_type, [$2],
                   [if test -z "$oft_real_type"; then
-                       if test "[$ac_cv_sizeof_]m4_bpatsubst(oft_type, [[^a-zA-Z0-9_]], [_])" = "$oft_target_size" ; then
+                       dnl AS_TR_SH expands literals via m4_translit, which is
+                       dnl locale-independent; m4_bpatsubst regex character
+                       dnl classes are not (e.g. cs_CZ.UTF-8 collates "ch" as
+                       dnl one element, mangling "char" -> "_ar").
+                       if test "[$ac_cv_sizeof_]AS_TR_SH(oft_type)" = "$oft_target_size" ; then
                            oft_real_type="oft_type"
                        fi
                    fi
diff --git a/config/opal_mca.m4 b/config/opal_mca.m4
index bb51d3bc5f1..38f985bf571 100644
--- a/config/opal_mca.m4
+++ b/config/opal_mca.m4
@@ -338,15 +338,62 @@ AC_DEFUN([MCA_CONFIGURE_PROJECT],[
     AC_SUBST(MCA_$1_FRAMEWORK_CORE_LIBS)
 ])
 
+# _MCA_TRACK_PRIORITY_RANGE(priority)
+# -----------------------------------
+# Fold the given priority into the running
+# mca_component_max_priority / mca_component_min_priority values.  Both
+# must be defined (to the empty string, if this is the first priority
+# seen) before invoking this macro.
+m4_define([_MCA_TRACK_PRIORITY_RANGE],
+    [m4_ifval(mca_component_max_priority,
+         [m4_if(m4_eval([$1] > mca_component_max_priority), [1],
+                [m4_define([mca_component_max_priority], [$1])])dnl
+          m4_if(m4_eval([$1] < mca_component_min_priority), [1],
+                [m4_define([mca_component_min_priority], [$1])])],
+         [m4_define([mca_component_max_priority], [$1])dnl
+          m4_define([mca_component_min_priority], [$1])])])
+
+# _MCA_EMIT_COMPONENT_IF_PRIORITY(project_name, framework_name,
+#                                 component_name, priority)
+# -------------------------------------------------------------
+# Emit component_name (preceded by a separator, if it is not the first
+# component emitted) if and only if its priority is the given priority.
+# mca_component_separator must be defined to the empty string before
+# the first invocation of this macro.
+m4_define([_MCA_EMIT_COMPONENT_IF_PRIORITY],
+    [m4_if(m4_eval(OPAL_EVAL_ARG([MCA_]$1[_]$2[_]$3[_PRIORITY]) == [$4]), [1],
+           [mca_component_separator[]$3[]m4_define([mca_component_separator], [, ])])])
+
 # MCA_ORDER_COMPONENT_LIST(project_name, framework_name)
+# ------------------------------------------------------
+# Define component_list to be the framework's m4-configure component
+# list, ordered from highest to lowest
+# MCA_<project>_<framework>_<component>_PRIORITY.  Every component in
+# the list must have a priority.
 AC_DEFUN([MCA_ORDER_COMPONENT_LIST], [
     m4_foreach(mca_component, [mca_$1_$2_m4_config_component_list],
                [m4_ifval(mca_component,
                     [m4_ifdef([MCA_]$1[_]$2[_]mca_component[_PRIORITY], [],
                          [m4_fatal([MCA_$1_$2_]mca_component[_PRIORITY not found, but required.])])])])
+dnl Find the highest and lowest priorities in the framework.
+    m4_define([mca_component_max_priority], [])dnl
+    m4_define([mca_component_min_priority], [])dnl
+    m4_foreach([mca_component], [mca_$1_$2_m4_config_component_list],
+               [m4_ifval(mca_component,
+                    [_MCA_TRACK_PRIORITY_RANGE(OPAL_EVAL_ARG([MCA_]$1[_]$2[_]mca_component[_PRIORITY]))])])dnl
+dnl Walk the priorities from highest to lowest, emitting the components
+dnl that have each priority.  Walking the priorities (vs. sorting the
+dnl components) means that components of equal priority are emitted in
+dnl the same relative order in which they appear in the original list.
+    m4_define([mca_component_separator], [])dnl
     m4_define([component_list],
-              [esyscmd([config/opal_mca_priority_sort.pl] m4_foreach([mca_component], [mca_$1_$2_m4_config_component_list],
-                        [m4_ifval(mca_component, [mca_component ]OPAL_EVAL_ARG([MCA_]$1[_]$2[_]mca_component[_PRIORITY ]))]))])
+        m4_dquote(m4_ifval(mca_component_max_priority,
+            [m4_for([mca_component_priority],
+                    mca_component_max_priority, mca_component_min_priority, -1,
+                [m4_foreach([mca_component], [mca_$1_$2_m4_config_component_list],
+                    [m4_ifval(mca_component,
+                         [_MCA_EMIT_COMPONENT_IF_PRIORITY($1, $2, mca_component,
+                                                          mca_component_priority)])])])])))
 ])
 
 AC_DEFUN([MCA_CHECK_IGNORED_PRIORITY], [
diff --git a/config/opal_mca_priority_sort.pl b/config/opal_mca_priority_sort.pl
deleted file mode 100755
index 4026e990edc..00000000000
--- a/config/opal_mca_priority_sort.pl
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/usr/bin/env perl
-#
-# Copyright (c) 2010      Sandia National Laboratories. All rights reserved.
-#
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-my $components;
-my @result;
-
-while (@ARGV) {
-    my $component;
-    $component->{"name"} = shift(@ARGV);
-    $component->{"value"} = shift(@ARGV);
-    push(@{$components}, $component);
-}
-
-foreach my $component (sort { $b->{value} <=> $a->{value} } @{$components}) {
-    push(@result, $component->{name});
-}
-sub commify_series {
-    (@_ == 0) ? ''                                      :
-    (@_ == 1) ? $_[0]                                   :
-                join(", ", @_[0 .. ($#_-1)], "$_[-1]");
-}
-
-print commify_series(@result);
diff --git a/config/opal_summary.m4 b/config/opal_summary.m4
index a922a836a17..67e6e959d5c 100644
--- a/config/opal_summary.m4
+++ b/config/opal_summary.m4
@@ -7,6 +7,7 @@ dnl Copyright (c) 2016      Research Organization for Information Science
 dnl                         and Technology (RIST). All rights reserved.
 dnl Copyright (c) 2022      Amazon.com, Inc. or its affiliates.  All Rights reserved.
 dnl Copyright (c) 2022      IBM Corporation.  All rights reserved.
+dnl Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 dnl $COPYRIGHT$
 dnl
 dnl Additional copyrights may follow
@@ -57,12 +58,6 @@ EOF
         else
             echo "Build MPI Fortran bindings: no" >&AS_MESSAGE_FD
         fi
-
-        if test $WANT_MPI_JAVA_BINDINGS -eq 1 ; then
-            echo "Build MPI Java bindings (experimental): yes" >&AS_MESSAGE_FD
-        else
-            echo "Build MPI Java bindings (experimental): no" >&AS_MESSAGE_FD
-        fi
     fi
 
     if test "$project_oshmem_amc" = "true" ; then
diff --git a/config/oshmem_configure_options.m4 b/config/oshmem_configure_options.m4
index 0e4b0ea55bc..a6347843c56 100644
--- a/config/oshmem_configure_options.m4
+++ b/config/oshmem_configure_options.m4
@@ -117,7 +117,7 @@ AS_IF([test "$enable_oshmem" = "no" && \
        AC_MSG_ERROR([Cannot continue])])
 
 # Cannot check if we can enable profiling because it is not yet
-# known whether the compiler supports weak symbols.
+# known whether the compiler supports weak aliases.
 
 
 #
diff --git a/config/oshmem_setup_profiling.m4 b/config/oshmem_setup_profiling.m4
index c31c3731075..6f76dba8179 100644
--- a/config/oshmem_setup_profiling.m4
+++ b/config/oshmem_setup_profiling.m4
@@ -16,20 +16,20 @@ AC_DEFUN([OSHMEM_SETUP_PROFILING],[
     AC_MSG_CHECKING([if pshmem will be enabled])
     AS_IF([test "$enable_oshmem" != "no" && \
            test "$enable_oshmem_profile" != "no"],
-          [AS_IF([test "$OPAL_C_HAVE_WEAK_SYMBOLS" -eq 1 && \
-                  test "$OPAL_C_HAVE_MACRO_WEAK_SYMBOLS" -eq 1],
+          [AS_IF([test "$OPAL_C_HAVE_WEAK_ALIASES" -eq 1 && \
+                  test "$OPAL_C_HAVE_MACRO_WEAK_ALIASES" -eq 1],
                  [ # We want OSHMEM and we have all the required weak
                    # symbol support
                   oshmem_profiling_support=1
-                  AC_MSG_RESULT([yes (weak symbols supported)])],
+                  AC_MSG_RESULT([yes (weak aliases supported)])],
                  [ # We want OSHMEM, but we do NOT have all the
-                   # required weak symbol support
+                   # required weak alias support
                   oshmem_profiling_support=0
-                  AC_MSG_RESULT([no (weak symbols not supported)])
-                  AS_IF([test "$OPAL_C_HAVE_WEAK_SYMBOLS" -eq 0],
-                        [AC_MSG_WARN([Weak symbols not supported by compiler])])
-                  AS_IF([test "$OPAL_C_HAVE_MACRO_WEAK_SYMBOLS" -eq 0],
-                       [AC_MSG_WARN([Macro weak symbols not supported by compiler])])
+                  AC_MSG_RESULT([no (weak aliases not supported)])
+                  AS_IF([test "$OPAL_C_HAVE_WEAK_ALIASES" -eq 0],
+                        [AC_MSG_WARN([Weak aliases not supported by compiler])])
+                  AS_IF([test "$OPAL_C_HAVE_MACRO_WEAK_ALIASES" -eq 0],
+                       [AC_MSG_WARN([Macro weak aliases not supported by compiler])])
                   AC_MSG_WARN([OpenSHMEM profiling is disabled.])
 
                   AS_IF([test "$enable_oshmem_profile" = "yes" && \
diff --git a/configure.ac b/configure.ac
index d4276b23284..6520e80afee 100644
--- a/configure.ac
+++ b/configure.ac
@@ -28,7 +28,7 @@
 # Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
 # Copyright (c) 2019      Triad National Security, LLC. All rights
 #                         reserved.
-# Copyright (c) 2023      Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2023-2026 Jeffrey M. Squyres.  All rights reserved.
 # Copyright (c) 2025      Nanook Consulting  All rights reserved.
 # $COPYRIGHT$
 #
@@ -151,7 +151,6 @@ m4_ifdef([project_ompi],
           AC_SUBST(libmpi_usempi_tkr_so_version)
           AC_SUBST(libmpi_usempi_ignore_tkr_so_version)
           AC_SUBST(libmpi_usempif08_so_version)
-          AC_SUBST(libmpi_java_so_version)
           AC_SUBST(libompitrace_so_version)])
 m4_ifdef([project_oshmem],
          [AC_SUBST(liboshmem_so_version)])
@@ -555,45 +554,23 @@ OPAL_C_GET_ALIGNMENT(size_t, OPAL_ALIGNMENT_SIZE_T)
 
 OPAL_CHECK_ALT_SHORT_FLOAT
 
-# Check system alignment requirements
-if test "$opal_want_heterogeneous" = 1; then
-    ompi_cv_c_word_size_align=yes
-else
-    AC_CACHE_CHECK([if word-sized integers must be word-size aligned],
-        [ompi_cv_c_word_size_align],
-        [AC_LANG_PUSH(C)
-         AC_RUN_IFELSE([AC_LANG_PROGRAM([dnl
-#include <stdlib.h>], [[    long data[2] = {0, 0};
-    long *lp;
-    int *ip;
-    ip = (int*) data;
-    ip++;
-    lp = (long*) ip;
-    return lp[0]; ]])],
-            [ompi_cv_c_word_size_align=no],
-            [ompi_cv_c_word_size_align=yes],
-            [ompi_cv_c_word_size_align=yes])])
-fi
-AS_IF([test $ompi_cv_c_word_size_align = yes], [results=1], [results=0])
-AC_DEFINE_UNQUOTED([OPAL_ALIGN_WORD_SIZE_INTEGERS], [$results],
-    [set to 1 if word-size integers must be aligned to word-size padding to prevent bus errors])
-
 #
 # Check for other compiler characteristics
 #
 
+OPAL_C_WEAK_ALIASES
+OPAL_C_MACRO_WEAK_ALIASES
 OPAL_C_WEAK_SYMBOLS
-OPAL_C_MACRO_WEAK_SYMBOLS
 
 # If we want the profiling layer:
-# - If the C compiler has weak symbols, use those.
+# - If the C compiler has weak aliases, use those.
 # - If not, then set to compile the code again with #define's in a
 #   separate directory.
 
-if test "$WANT_WEAK_SYMBOLS" = "0"; then
-    OPAL_C_HAVE_WEAK_SYMBOLS=0
+if test "$WANT_WEAK_ALIASES" = "0"; then
+    OPAL_C_HAVE_WEAK_ALIASES=0
 fi
-if test "$OPAL_C_HAVE_WEAK_SYMBOLS" = "1"; then
+if test "$OPAL_C_HAVE_WEAK_ALIASES" = "1"; then
     OMPI_PROFILING_COMPILE_SEPARATELY=0
 else
     OMPI_PROFILING_COMPILE_SEPARATELY=1
@@ -641,13 +618,6 @@ AS_IF([test "$opal_cv_compiler_FAMILYNAME" = "GNU" && \
        AC_MSG_ERROR([Cannot continue])
       ])
 
-##################################
-# Java MPI Binding request
-##################################
-# Only needed for OMPI
-m4_ifdef([project_ompi], [OMPI_SETUP_JAVA_BINDINGS])
-
-
 ##################################
 # MPI / OpenSHMEM API profiling layer
 ##################################
@@ -1552,8 +1522,6 @@ AC_CONFIG_FILES([
     test/util/Makefile
 ])
 
-m4_ifdef([project_ompi], [AC_CONFIG_FILES([test/monitoring/Makefile test/spc/Makefile])])
-
 AC_CONFIG_FILES([contrib/dist/mofed/debian/rules],
                 [chmod +x contrib/dist/mofed/debian/rules])
 AC_CONFIG_FILES([contrib/dist/mofed/compile_debian_mlnx_example],
diff --git a/contrib/annual-maintenance/convert-to-git.txt b/contrib/annual-maintenance/convert-to-git.txt
deleted file mode 100644
index fde32ad9205..00000000000
--- a/contrib/annual-maintenance/convert-to-git.txt
+++ /dev/null
@@ -1,60 +0,0 @@
-From Dave:
-
-For fun, here's the Git version of the "AUTHORS with commits in the past year" part of your script:
-
-----8<----
-savbu-usnic-a ~/g/ompi-svn-mirror git:main ❮❮❮ git log --all --since='1 year ago' --pretty=tformat:'%ae' | sort | uniq -c
-    39 adrian@open-mpi-git-mirror.example.com
-     3 alex@open-mpi-git-mirror.example.com
-     5 alinas@open-mpi-git-mirror.example.com
-     9 amikheev@open-mpi-git-mirror.example.com
-    90 bosilca@open-mpi-git-mirror.example.com
-    22 brbarret@open-mpi-git-mirror.example.com
-     5 devendar@open-mpi-git-mirror.example.com
-    60 dgoodell@open-mpi-git-mirror.example.com
-     8 edgar@open-mpi-git-mirror.example.com
-    48 ggouaillardet@open-mpi-git-mirror.example.com
-     4 hadi@open-mpi-git-mirror.example.com
-   295 hjelmn@open-mpi-git-mirror.example.com
-     4 hpcchris@open-mpi-git-mirror.example.com
-     2 hppritcha@open-mpi-git-mirror.example.com
-    28 jladd@open-mpi-git-mirror.example.com
-     2 jroman@open-mpi-git-mirror.example.com
-   697 jsquyres@open-mpi-git-mirror.example.com
-    11 jurenz@open-mpi-git-mirror.example.com
-     3 manjugv@open-mpi-git-mirror.example.com
-   209 miked@open-mpi-git-mirror.example.com
-    24 mpiteam@open-mpi-git-mirror.example.com
-     4 naughtont@open-mpi-git-mirror.example.com
-    50 osvegis@open-mpi-git-mirror.example.com
-     2 pasha@open-mpi-git-mirror.example.com
-     5 regrant@open-mpi-git-mirror.example.com
-     6 rfaucett@open-mpi-git-mirror.example.com
-  1516 rhc@open-mpi-git-mirror.example.com
-    79 rolfv@open-mpi-git-mirror.example.com
-     2 swise@open-mpi-git-mirror.example.com
-     7 vasily@open-mpi-git-mirror.example.com
-     1 vvenkatesan@open-mpi-git-mirror.example.com
-    10 yosefe@open-mpi-git-mirror.example.com
-----8<----
-
-And the "NO commits":
-----8<----
-savbu-usnic-a ~/g/ompi-svn-mirror git:main ❯❯❯ git log --all --since='1 year ago' --pretty=tformat:'%ae' | sort | uniq > /tmp/active ; git log --pretty=tformat:'%ae' --all | sort | uniq > /tmp/all ; diff -u
-/tmp/all /tmp/active | grep '^-[^-]'
--abbyz@open-mpi-git-mirror.example.com
--adi@open-mpi-git-mirror.example.com
--adkulkar@open-mpi-git-mirror.example.com
--afriedle@open-mpi-git-mirror.example.com
--alekseys@open-mpi-git-mirror.example.com
--alexma@open-mpi-git-mirror.example.com
--angskun@open-mpi-git-mirror.example.com
--Anya@open-mpi-git-mirror.example.com
--apant@open-mpi-git-mirror.example.com
--bbenton@open-mpi-git-mirror.example.com
--bouteill@open-mpi-git-mirror.example.com
--casswell@open-mpi-git-mirror.example.com
--coti@open-mpi-git-mirror.example.com
-[...]
-----8<----
-
diff --git a/contrib/annual-maintenance/find-committers-from-last-year.pl b/contrib/annual-maintenance/find-committers-from-last-year.pl
deleted file mode 100755
index 2b9110fb2df..00000000000
--- a/contrib/annual-maintenance/find-committers-from-last-year.pl
+++ /dev/null
@@ -1,114 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-
-use Data::Dumper;
-
-##########################################################################
-
-# Read in the AUTHORS file
-
-die "Run this script at the top of an OMPI SVN tree"
-    if (! -r "AUTHORS");
-
-print "Reading AUTHORS file...\n";
-open(AUTHORS, "AUTHORS") || die "Can't open AUTHORS file";
-my $in = 0;
-my $authors;
-my $count = 0;
-while (<AUTHORS>) {
-    chomp;
-
-    if ($in) {
-        if (length($_) == 0) {
-            $in = 0;
-            next;
-        }
-
-        # There's probably a good regexp that will sort this better,
-        # but I'm a little too lazy at the moment.  :-( So just use
-        # fixed widths for the name and affiliation fields, and then
-        # strip off trailing whitespace.
-        m/(\S+)\s+/;
-        my $username = $1;
-        my $name = substr($_, 14, 27);
-        my $affiliation = substr($_, 42);
-        $name =~ s/(\s+)$//;
-        $affiliation =~ s/(\s+)$//;
-
-        $authors->{$username} = {
-            username => $username,
-            name => $name,
-            affiliation => $affiliation,
-            active => 0,
-        };
-        ++$count;
-    }
-
-    else {
-        $in = 1
-            if (/^------.+ .+ .+-----$/);
-    }
-}
-close(AUTHORS);
-print "Read $count authors from AUTHORS file\n";
-
-##########################################################################
-
-# Read committers from SVN log over the past year
-
-my $trunk = "https://svn.open-mpi.org/svn/ompi/trunk";
-
-my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) =
-    localtime(time);
-
-$year += 1900;
-my $today = sprintf("%04d-%02d-%02d", $year, $mon+1, $mday);
-my $year_ago = sprintf("%04d-%02d-%02d", $year-1, $mon+1, $mday);
-
-$count = 0;
-my $committers;
-print "Reading SVN log to find committers over past year...\n";
-open(SVN, "svn log -v -r '{$today}:{$year_ago}' $trunk|") ||
-    die "Can't open svn log";
-while (<SVN>) {
-    if (m/^(r\d+) \| (\S+) \| (\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d)/) {
-        print "Indexed $1 ($3)\n";
-
-        if (!exists($committers->{$2})) {
-            $committers->{$2} = 1;
-            ++$count;
-        }
-
-        if (!exists($authors->{$2})) {
-            print "WARNING: committer $2 is not in AUTHORS!\n";
-        } else {
-            $authors->{$2}->{active} = 1;
-        }
-    }
-}
-close(SVN);
-print "Found $count SVN committers over the last year\n";
-
-##########################################################################
-
-# Print list of committers over the past year
-
-print "
-AUTHORS with commits in the past year:
---------------------------------------\n";
-foreach my $username (sort(keys(%{$authors}))) {
-    if ($authors->{$username}->{active}) {
-        print "$username -> $authors->{$username}->{name}, $authors->{$username}->{affiliation}\n";
-    }
-}
-
-print "
-AUTHORS with NO commits in the past year:
------------------------------------------\n";
-foreach my $username (sort(keys(%{$authors}))) {
-    if (!$authors->{$username}->{active}) {
-        print "$username -> $authors->{$username}->{name}, $authors->{$username}->{affiliation}\n";
-    }
-}
-
diff --git a/contrib/build-mca-comps-outside-of-tree/btl_tcp2_endpoint.c b/contrib/build-mca-comps-outside-of-tree/btl_tcp2_endpoint.c
index 385f645d062..339db08da89 100644
--- a/contrib/build-mca-comps-outside-of-tree/btl_tcp2_endpoint.c
+++ b/contrib/build-mca-comps-outside-of-tree/btl_tcp2_endpoint.c
@@ -122,7 +122,7 @@ static void mca_btl_tcp2_endpoint_send_handler(int sd, short flags, void* user);
 
 void mca_btl_tcp_endpoint_dump(mca_btl_base_endpoint_t* btl_endpoint, const char* msg)
 {
-    char src[64], dst[64], *status;
+    char src[INET_ADDRSTRLEN], dst[INET_ADDRSTRLEN], *status;
     int sndbuf, rcvbuf, nodelay, flags = -1;
 #if OPAL_ENABLE_IPV6
     struct sockaddr_storage inaddr;
@@ -144,7 +144,7 @@ void mca_btl_tcp_endpoint_dump(mca_btl_base_endpoint_t* btl_endpoint, const char
             }
         }
 #else
-        sprintf(src, "%s", inet_ntoa(inaddr.sin_addr));
+        inet_ntop(AF_INET, &inaddr.sin_addr, src, sizeof(src));
 #endif
         getpeername(btl_endpoint->endpoint_sd, (struct sockaddr*)&inaddr, &addrlen);
 #if OPAL_ENABLE_IPV6
@@ -156,7 +156,7 @@ void mca_btl_tcp_endpoint_dump(mca_btl_base_endpoint_t* btl_endpoint, const char
             }
         }
 #else
-        sprintf(dst, "%s", inet_ntoa(inaddr.sin_addr));
+        inet_ntop(AF_INET, &inaddr.sin_addr, dst, sizeof(dst));
 #endif
 
         if((flags = fcntl(btl_endpoint->endpoint_sd, F_GETFL, 0)) < 0) {
diff --git a/contrib/openmpi-valgrind.supp b/contrib/openmpi-valgrind.supp
index 0a3ba945658..ca7826a3bf2 100644
--- a/contrib/openmpi-valgrind.supp
+++ b/contrib/openmpi-valgrind.supp
@@ -67,22 +67,6 @@
 #
 ###############################################################
 
-# inet_ntoa on linux mallocs a static buffer.  We can't free
-# it, so we have to live with it
-{
-  linux_inet_ntoa
-  Memcheck:Leak
-  fun:malloc
-  fun:inet_ntoa
-}
-{
-  linux_inet_ntoa_thread
-  Memcheck:Leak
-  fun:calloc
-  fun:pthread_setspecific
-  fun:inet_ntoa
-}
-
 
 ###############################################################
 #
diff --git a/contrib/platform/hadoop/cisco b/contrib/platform/hadoop/cisco
index ac506c30365..25a5e4f64e9 100644
--- a/contrib/platform/hadoop/cisco
+++ b/contrib/platform/hadoop/cisco
@@ -14,7 +14,6 @@ enable_mpi_fortran=no
 enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
 enable_cxx_exceptions=no
-enable_mpi_java=yes
 enable_per_user_config_files=no
 enable_script_wrapper_compilers=no
 enable_orterun_prefix_by_default=yes
@@ -27,5 +26,3 @@ with_portals=no
 with_valgrind=no
 with_slurm=/opt/slurm/2.1.0
 with_openib=no
-with_jdk_bindir=/usr/lib/jvm/java-1.6.0/bin
-with_jdk_headers=/usr/lib/jvm/java-1.6.0/include
diff --git a/contrib/platform/hadoop/linux b/contrib/platform/hadoop/linux
index 4cd76ed4db0..fd5be6316ec 100644
--- a/contrib/platform/hadoop/linux
+++ b/contrib/platform/hadoop/linux
@@ -15,7 +15,6 @@ enable_mpi_fortran=no
 enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
 enable_cxx_exceptions=no
-enable_mpi_java=yes
 enable_io_romio=no
 enable_mca_no_build=memchecker
 with_memory_manager=no
diff --git a/contrib/platform/hadoop/mac b/contrib/platform/hadoop/mac
index 844e1d4ec6c..31238c40483 100644
--- a/contrib/platform/hadoop/mac
+++ b/contrib/platform/hadoop/mac
@@ -13,12 +13,9 @@ enable_ipv6=no
 enable_mpi_fortran=no
 enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
-enable_mpi_java=yes
 enable_memchecker=no
 enable_mca_no_build=memchecker
 with_memory_manager=no
 with_devel_headers=yes
 with_xgrid=no
 with_slurm=no
-with_jdk_bindir=/usr/bin
-with_jdk_headers=/System/Library/Frameworks/JavaVM.framework/Versions/Current/Headers
diff --git a/contrib/platform/intel/bend/ext b/contrib/platform/intel/bend/ext
index 127e61f9e80..46467051dc6 100644
--- a/contrib/platform/intel/bend/ext
+++ b/contrib/platform/intel/bend/ext
@@ -15,7 +15,6 @@ enable_mpi_fortran=yes
 enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
 enable_cxx_exceptions=no
-enable_mpi_java=no
 enable_io_romio=no
 enable_contrib_no_build=libnbc
 with_memory_manager=no
diff --git a/contrib/platform/intel/bend/gadget b/contrib/platform/intel/bend/gadget
index 152f17f8191..87dc62ff358 100644
--- a/contrib/platform/intel/bend/gadget
+++ b/contrib/platform/intel/bend/gadget
@@ -16,7 +16,6 @@ enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
 enable_cxx_exceptions=no
 enable_oshmem=no
-enable_mpi_java=no
 enable_io_romio=no
 enable_builtin_atomics=no
 enable_contrib_no_build=libnbc
diff --git a/contrib/platform/intel/bend/gadget-optimized b/contrib/platform/intel/bend/gadget-optimized
index 99f459f31eb..365623c9f68 100644
--- a/contrib/platform/intel/bend/gadget-optimized
+++ b/contrib/platform/intel/bend/gadget-optimized
@@ -16,7 +16,6 @@ enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
 enable_cxx_exceptions=no
 enable_oshmem=no
-enable_mpi_java=no
 enable_io_romio=no
 enable_contrib_no_build=libnbc
 with_memory_manager=no
diff --git a/contrib/platform/intel/bend/linux-optimized b/contrib/platform/intel/bend/linux-optimized
index fa9350f4703..efffa66c26b 100644
--- a/contrib/platform/intel/bend/linux-optimized
+++ b/contrib/platform/intel/bend/linux-optimized
@@ -15,7 +15,6 @@ enable_mpi_fortran=no
 enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
 enable_cxx_exceptions=no
-enable_mpi_java=yes
 enable_io_romio=no
 enable_mca_no_build=memchecker
 enable_contrib_no_build=libnbc
diff --git a/contrib/platform/intel/bend/mac-optimized b/contrib/platform/intel/bend/mac-optimized
index d5e239ad73a..c1747db2cdf 100644
--- a/contrib/platform/intel/bend/mac-optimized
+++ b/contrib/platform/intel/bend/mac-optimized
@@ -14,7 +14,6 @@ enable_ipv6=no
 enable_mpi_fortran=no
 enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
-enable_mpi_java=yes
 enable_memchecker=no
 enable_mca_no_build=memchecker
 enable_contrib_no_build=libnbc
@@ -22,6 +21,4 @@ with_memory_manager=no
 with_devel_headers=yes
 with_xgrid=no
 with_slurm=no
-with_jdk_bindir=/usr/bin
-with_jdk_headers=/System/Library/Frameworks/JavaVM.framework/Versions/Current/Headers
 with_mpi_param_check=no
diff --git a/contrib/platform/intel/bend/ubuntu b/contrib/platform/intel/bend/ubuntu
index 98df8b25777..49d3da0d813 100644
--- a/contrib/platform/intel/bend/ubuntu
+++ b/contrib/platform/intel/bend/ubuntu
@@ -15,7 +15,6 @@ enable_mpi_fortran=no
 enable_mpi_cxx=no
 enable_mpi_cxx_seek=no
 enable_cxx_exceptions=no
-enable_mpi_java=no
 enable_io_romio=no
 enable_contrib_no_build=libnbc
 enable_install_libpmix=yes
diff --git a/contrib/platform/lanl/macosx-dynamic-java b/contrib/platform/lanl/macosx-dynamic-java
deleted file mode 100644
index 2cb0976cde5..00000000000
--- a/contrib/platform/lanl/macosx-dynamic-java
+++ /dev/null
@@ -1,21 +0,0 @@
-with_memory_manager=no
-enable_mem_debug=yes
-enable_mem_profile=no
-enable_debug_symbols=yes
-enable_binaries=yes
-with_devel_headers=yes
-enable_heterogeneous=no
-enable_picky=yes
-enable_debug=yes
-enable_shared=yes
-enable_static=no
-enable_contrib_no_build=libnbc
-with_xgrid=no
-enable_io_romio=no
-enable_ipv6=no
-enable_mpi_fortran=no
-enable_mpi_cxx=no
-enable_mpi_cxx_seek=no
-enable_mpi_java=yes
-enable_memchecker=no
-enable_mca_no_build=pml-cm,filem,pml-v
diff --git a/contrib/platform/lanl/macosx-dynamic-java.conf b/contrib/platform/lanl/macosx-dynamic-java.conf
deleted file mode 100644
index c888e678047..00000000000
--- a/contrib/platform/lanl/macosx-dynamic-java.conf
+++ /dev/null
@@ -1,60 +0,0 @@
-#
-# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
-#                         University Research and Technology
-#                         Corporation.  All rights reserved.
-# Copyright (c) 2004-2005 The University of Tennessee and The University
-#                         of Tennessee Research Foundation.  All rights
-#                         reserved.
-# Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
-#                         University of Stuttgart.  All rights reserved.
-# Copyright (c) 2004-2005 The Regents of the University of California.
-#                         All rights reserved.
-# Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-# This is the default system-wide MCA parameters defaults file.
-# Specifically, the MCA parameter "mca_param_files" defaults to a
-# value of
-# "$HOME/.openmpi/mca-params.conf:$sysconf/openmpi-mca-params.conf"
-# (this file is the latter of the two).  So if the default value of
-# mca_param_files is not changed, this file is used to set system-wide
-# MCA parameters.  This file can therefore be used to set system-wide
-# default MCA parameters for all users.  Of course, users can override
-# these values if they want, but this file is an excellent location
-# for setting system-specific MCA parameters for those users who don't
-# know / care enough to investigate the proper values for them.
-
-# Note that this file is only applicable where it is visible (in a
-# filesystem sense).  Specifically, MPI processes each read this file
-# during their startup to determine what default values for MCA
-# parameters should be used.  mpirun does not bundle up the values in
-# this file from the node where it was run and send them to all nodes;
-# the default value decisions are effectively distributed.  Hence,
-# these values are only applicable on nodes that "see" this file.  If
-# $sysconf is a directory on a local disk, it is likely that changes
-# to this file will need to be propagated to other nodes.  If $sysconf
-# is a directory that is shared via a networked filesystem, changes to
-# this file will be visible to all nodes that share this $sysconf.
-
-# The format is straightforward: one per line, mca_param_name =
-# rvalue.  Quoting is ignored (so if you use quotes or escape
-# characters, they'll be included as part of the value).  For example:
-
-# Disable run-time MPI parameter checking
-#   mpi_param_check = 0
-
-# Note that the value "~/" will be expanded to the current user's home
-# directory.  For example:
-
-# Change component loading path
-#   component_path = /usr/local/lib/openmpi:~/my_openmpi_components
-
-# See "ompi_info --param all all" for a full listing of Open MPI MCA
-# parameters available and their default values.
-#
-
diff --git a/contrib/platform/mellanox/optimized b/contrib/platform/mellanox/optimized
index f75b8e09c0f..fa476c4bd86 100644
--- a/contrib/platform/mellanox/optimized
+++ b/contrib/platform/mellanox/optimized
@@ -1,6 +1,10 @@
 enable_mca_no_build=coll-ml,btl-uct
 enable_debug_symbols=yes
-enable_orterun_prefix_by_default=yes
+# orterun/mpirun-prefix-by-default is deprecated and intentionally not replaced
+# by enable_prte_prefix_by_default here: platform variables are sourced into the
+# top-level configure and do not reach the PRRTE sub-configure, while leaving
+# the variable unset makes ompi_setup_prrte.m4 pass
+# --enable-prte-prefix-by-default to PRRTE on its own.
 with_devel_headers=yes
 enable_oshmem=yes
 enable_oshmem_fortran=yes
diff --git a/contrib/update-my-copyright.pl b/contrib/update-my-copyright.pl
index 3ac826bfa32..1b3dd7a011f 100755
--- a/contrib/update-my-copyright.pl
+++ b/contrib/update-my-copyright.pl
@@ -269,6 +269,7 @@ sub quiet_print {
 # Returns a list of file names (relative to pwd) which git considers
 # to be modified.
 sub find_modified_files {
+    my %seen;
     my @files = ();
 
     # Number of path entries to remove from ${top}-relative paths.
@@ -322,10 +323,73 @@ sub find_modified_files {
             my $relname = $fullname;
             $relname =~ s!^([^/]*/){$n_strip}!!g;
 
-            push @files, $relname
-                if (-f $relname);
+            if (-f $relname && !$seen{$relname}++) {
+                push @files, $relname;
+            }
         }
     }
 
+    # Also include files changed in commits on this branch that have not
+    # yet been pushed / are not in the base branch.  This covers the common
+    # case of running the script after committing.
+    #
+    # Strategy: find a base ref whose merge-base with HEAD is not HEAD
+    # itself (i.e. there are actual commits on this branch).  Try, in order:
+    #   1. The upstream tracking branch — but only if it is not the current
+    #      branch pushed to a remote (which would give merge-base == HEAD).
+    #   2. origin/HEAD (the remote's default branch).
+    #   3. Well-known names: origin/main, origin/master, main, master.
+    my $head_sha = `git rev-parse HEAD 2>/dev/null`;
+    chomp($head_sha);
+    my $current_branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`;
+    chomp($current_branch);
+
+    my $base_ref = "";
+    my @candidates;
+
+    # Upstream tracking branch (skip if it tracks the same branch on the remote)
+    my $upstream = `git rev-parse --abbrev-ref \@{upstream} 2>/dev/null`;
+    chomp($upstream);
+    if ($upstream) {
+        # e.g. "origin/bigcount-datatypes" tracks the same branch — skip it
+        my $upstream_branch = $upstream;
+        $upstream_branch =~ s!^[^/]+/!!;   # strip "origin/" prefix
+        push @candidates, $upstream unless ($upstream_branch eq $current_branch);
+    }
+
+    # Remote default branch and common well-known names (avoid origin/HEAD —
+    # it can be a stale symref pointing to the wrong branch)
+    push @candidates, "origin/main", "origin/master", "main", "master";
+
+    for my $candidate (@candidates) {
+        my $sha = `git rev-parse --verify $candidate 2>/dev/null`;
+        chomp($sha);
+        next unless $sha;
+        my $mb = `git merge-base HEAD $candidate 2>/dev/null`;
+        chomp($mb);
+        # Only useful if the merge-base is not HEAD itself
+        next unless ($mb && $mb ne $head_sha);
+        $base_ref = $candidate;
+        last;
+    }
+
+    if ($base_ref) {
+        my $merge_base = `git merge-base HEAD $base_ref 2>/dev/null`;
+        chomp($merge_base);
+        quiet_print "==> Using base ref '$base_ref' (merge-base: $merge_base)\n";
+        my $diff_cmd = "git diff --name-only --diff-filter=ACMR $merge_base HEAD -- .";
+        quiet_print "==> Running: \"$diff_cmd\"\n";
+        my @diff_files = split /\n/, `$diff_cmd`;
+        for my $fullname (@diff_files) {
+            my $relname = $fullname;
+            $relname =~ s!^([^/]*/){$n_strip}!!g;
+            if (-f $relname && !$seen{$relname}++) {
+                push @files, $relname;
+            }
+        }
+    } else {
+        quiet_print "==> WARNING: Could not determine base branch for branch diff\n";
+    }
+
     return @files;
 }
diff --git a/docs/Makefile.am b/docs/Makefile.am
index a6edc6ae045..0afec54eed0 100644
--- a/docs/Makefile.am
+++ b/docs/Makefile.am
@@ -1,6 +1,6 @@
 #
 # Copyright (c) 2022 Cisco Systems, Inc.  All rights reserved.
-# Copyright (c) 2023-2025 Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2023-2026 Jeffrey M. Squyres.  All rights reserved.
 # Copyright (c) 2025      Triad National Security, LLC.  All rights reserved.
 #
 # $COPYRIGHT$
@@ -36,6 +36,8 @@ SPHINX_OPTS       ?= -W --keep-going -j auto
 # However, it is necessary to list $(srcdir) when using wildcards.
 TEXT_SOURCE_FILES  = \
         $(srcdir)/license/*.txt
+MARKDOWN_SOURCE_FILES = \
+        $(top_srcdir)/.github/CODE_OF_CONDUCT.md
 IMAGE_SOURCE_FILES = \
         $(srcdir)/openmpi_logo.png \
         $(srcdir)/installing-open-mpi/required-support-libraries-dependency-graph.png \
@@ -62,12 +64,22 @@ RST_SOURCE_FILES   = \
 EXTRA_DIST         = \
         requirements.txt \
         no-prrte-content.rst.txt \
+        generate-code-of-conduct-rst.py \
         generate-mpi-man3-bindings.py \
+        generate-llm-docs.py \
+        validate-llm-docs.py \
+        ompi_docs_common.py \
         mpi-standard-apis.json \
+        llms-src/openmpi-mpi-api.schema.json \
+        llms-src/openmpi-docs-manifest.schema.json \
+        llms-src/openmpi-mpi-interface-guide.md \
+        llms-src/openmpi-mpi-examples.md \
+        llms-src/openmpi-runtime-introspection.md \
         html \
         man \
         $(SPHINX_CONFIG) \
         $(TEXT_SOURCE_FILES) \
+        $(MARKDOWN_SOURCE_FILES) \
         $(IMAGE_SOURCE_FILES) \
         $(RST_SOURCE_FILES)
 
@@ -190,6 +202,7 @@ OMPI_MAN3 = \
         MPI_Errors.3 \
         MPI_Exscan.3 \
         MPI_Exscan_init.3 \
+        MPI_F_sync_reg.3 \
         MPI_Fetch_and_op.3 \
         MPI_File_c2f.3 \
         MPI_File_call_errhandler.3 \
@@ -455,10 +468,12 @@ OMPI_MAN3 = \
         MPI_T_category_get_categories.3 \
         MPI_T_category_get_cvars.3 \
         MPI_T_category_get_events.3 \
+        MPI_T_category_get_index.3 \
         MPI_T_category_get_info.3 \
         MPI_T_category_get_num.3 \
         MPI_T_category_get_num_events.3 \
         MPI_T_category_get_pvars.3 \
+        MPI_T_cvar_get_index.3 \
         MPI_T_cvar_get_info.3 \
         MPI_T_cvar_get_num.3 \
         MPI_T_cvar_handle_alloc.3 \
@@ -490,6 +505,7 @@ OMPI_MAN3 = \
         MPI_T_finalize.3 \
         MPI_T_init_thread.3 \
         MPI_Topo_test.3 \
+        MPI_T_pvar_get_index.3 \
         MPI_T_pvar_get_info.3 \
         MPI_T_pvar_get_num.3 \
         MPI_T_pvar_handle_alloc.3 \
@@ -868,10 +884,22 @@ OMPI_MAN3_RST = $(OMPI_MAN3:%.3=man-openmpi/man3/%.3.rst)
 OMPI_MAN3_BUILT = $(OMPI_MAN3:%.3=$(MAN_OUTDIR)/%.3)
 OMPI_MAN3_INSTALL_FROM = $(OMPI_MAN3:%.3=$(MAN_INSTALL_FROM)/%.3)
 
+# Generate this file from CODE_OF_CONDUCT.md as part of the Sphinx
+# docs build.
+CODE_OF_CONDUCT_RST = $(builddir)/code-of-conduct.rst
+
 # Use this one file as a sentinel for building all the Open MPI man
 # page API bindings files
 SENTINEL_OMPI_MAN3_BINDING = $(builddir)/man-openmpi/man3/bindings/mpi_init.rst
 
+# Stamp file marking a completed LLM-friendly documentation generator run.
+# A stamp (touched unconditionally after the generator) is used rather than a
+# generated artifact: the generator only rewrites files whose content changed,
+# so an artifact's mtime would not advance when only *other* artifacts changed,
+# and the HTML copy step below could be skipped.  The stamp lives outside the
+# llms-build/ staging tree so the generator's stale-file pruning leaves it.
+SENTINEL_OMPI_LLM = $(builddir)/llms-build.stamp
+
 OMPI_MAN7_RST = $(OMPI_MAN7:%.7=man-openmpi/man7/%.7.rst)
 OMPI_MAN7_BUILT = $(OMPI_MAN7:%.7=$(MAN_OUTDIR)/%.7)
 OMPI_MAN7_INSTALL_FROM = $(OMPI_MAN7:%.7=$(MAN_INSTALL_FROM)/%.7)
@@ -890,8 +918,8 @@ OSHMEM_MAN3_INSTALL_FROM = $(OSHMEM_MAN3:%.3=$(MAN_INSTALL_FROM)/%.3)
 # Sphinx-generated man pages) -- they exist directly in Git.  We
 # *always* want these files to be in EXTRA_DIST (so that they're in
 # distribution tarballs).  We'll decide later whether we install each
-# of these (e.g., if configure disabled the Java bindings, we won't
-# install mpijavac.1).
+# of these (e.g., if configure did not find a C++ compiler, we won't
+# install mpic++.1).
 OMPI_MAN1_C_REDIRECTS = man-openmpi/man1/mpicc.1
 OMPI_MAN1_CXX_REDIRECTS = \
         man-openmpi/man1/mpicxx.1 \
@@ -900,7 +928,6 @@ OMPI_MAN1_FORTRAN_REDIRECTS = \
         man-openmpi/man1/mpifort.1 \
         man-openmpi/man1/mpif77.1 \
         man-openmpi/man1/mpif90.1
-OMPI_MAN1_JAVA_REDIRECTS = man-openmpi/man1/mpijavac.1
 
 OSHMEM_MAN1_C_REDIRECTS = \
         man-openshmem/man1/oshcc.1 \
@@ -918,7 +945,6 @@ EXTRA_DIST += \
         $(OMPI_MAN1_C_REDIRECTS) \
         $(OMPI_MAN1_CXX_REDIRECTS) \
         $(OMPI_MAN1_FORTRAN_REDIRECTS) \
-        $(OMPI_MAN1_JAVA_REDIRECTS) \
         $(OSHMEM_MAN1_C_REDIRECTS) \
         $(OSHMEM_MAN1_CXX_REDIRECTS) \
         $(OSHMEM_MAN1_FORTRAN_REDIRECTS)
@@ -950,7 +976,7 @@ man: $(ALL_MAN_BUILT)
 # Remove the copies of the built HTML and man pages to get back to a
 # clean git clone.
 maintainer-clean-local:
-	rm -rf html man man-openmpi/man3/bindings
+	rm -rf html man man-openmpi/man3/bindings llms-build llms-build.stamp $(CODE_OF_CONDUCT_RST)
 
 # If we're doing a VPATH build, we may have "html" and "man"
 # directories in the build tree (e.g., if we did "make dist").  Remove
@@ -1032,15 +1058,41 @@ $(builddir)/man-openmpi/man3/bindings:
 
 $(SENTINEL_OMPI_MAN3_BINDING): $(builddir)/man-openmpi/man3/bindings
 $(SENTINEL_OMPI_MAN3_BINDING): generate-mpi-man3-bindings.py
+$(SENTINEL_OMPI_MAN3_BINDING): ompi_docs_common.py
 $(SENTINEL_OMPI_MAN3_BINDING): mpi-standard-apis.json
 	$(OMPI_V_GEN) $(PYTHON3) $(srcdir)/generate-mpi-man3-bindings.py \
 		--srcdir $(srcdir) --builddir $(builddir)
 
+# Generate the LLM-friendly artifacts into the build-tree staging
+# directory.  This must run after the man3 bindings (whose generated RST
+# the LLM generator include-expands) and before Sphinx (which copies the
+# staging tree into the HTML output, below).
+$(SENTINEL_OMPI_LLM): generate-llm-docs.py
+$(SENTINEL_OMPI_LLM): ompi_docs_common.py
+$(SENTINEL_OMPI_LLM): mpi-standard-apis.json
+$(SENTINEL_OMPI_LLM): llms-src/openmpi-mpi-interface-guide.md
+$(SENTINEL_OMPI_LLM): llms-src/openmpi-mpi-examples.md
+$(SENTINEL_OMPI_LLM): llms-src/openmpi-runtime-introspection.md
+$(SENTINEL_OMPI_LLM): llms-src/openmpi-mpi-api.schema.json
+$(SENTINEL_OMPI_LLM): llms-src/openmpi-docs-manifest.schema.json
+$(SENTINEL_OMPI_LLM): $(RST_SOURCE_FILES)
+$(SENTINEL_OMPI_LLM): $(SENTINEL_OMPI_MAN3_BINDING)
+	$(OMPI_V_GEN) $(PYTHON3) $(srcdir)/generate-llm-docs.py \
+		--srcdir $(srcdir) --builddir $(builddir)
+	@touch $@
+
+$(CODE_OF_CONDUCT_RST): $(top_srcdir)/.github/CODE_OF_CONDUCT.md
+$(CODE_OF_CONDUCT_RST): generate-code-of-conduct-rst.py
+	$(OMPI_V_GEN) $(PYTHON3) $(srcdir)/generate-code-of-conduct-rst.py \
+		--input $(top_srcdir)/.github/CODE_OF_CONDUCT.md --output $@
+
 $(ALL_MAN_BUILT): $(builddir)/prrte-rst-content
 $(ALL_MAN_BUILT): $(builddir)/schizo-ompi-rst-content/schizo-ompi-cli.rstxt
 $(ALL_MAN_BUILT): $(RST_SOURCE_FILES) $(IMAGE_SOURCE_FILES)
 $(ALL_MAN_BUILT): $(TEXT_SOURCE_FILES) $(SPHINX_CONFIG)
+$(ALL_MAN_BUILT): $(CODE_OF_CONDUCT_RST)
 $(ALL_MAN_BUILT): $(SENTINEL_OMPI_MAN3_BINDING)
+$(ALL_MAN_BUILT): $(SENTINEL_OMPI_LLM)
 
 # Render the RST source into both 1) full HTML docs and 2) nroff man
 # pages.
@@ -1103,6 +1155,7 @@ $(ALL_MAN_BUILT):
 	    OPAL_USING_INTERNAL_PMIX="$(OPAL_USING_INTERNAL_PMIX)" \
 	    OMPI_PRRTE_DOCS_URL_BASE="$(OMPI_PRRTE_DOCS_URL_BASE)" \
 	    OMPI_USING_INTERNAL_PRRTE="$(OMPI_USING_INTERNAL_PRRTE)" \
+	    OMPI_LLM_BUILDDIR="$(builddir)" \
 	    $(SPHINX_BUILD) -M html "$(builddir)" "$(OUTDIR)" $(SPHINX_OPTS)
 	$(OMPI_V_SPHINX_HTML) \
 	    OMPI_TOP_SRCDIR="$(top_srcdir)" \
@@ -1129,8 +1182,35 @@ linkcheck:
 #
 # Also, if this is a VPATH build, then we made a copy of a bunch of
 # RST source files to the build tree.  So delete all of those, too.
+# Validate the generated LLM-friendly artifacts (JSON Schema, cross-field
+# invariants, no unresolved RST, manifest integrity, sample sync) and confirm
+# the generator is deterministic at a fixed SOURCE_DATE_EPOCH.  Runs as part of
+# "make check"; depends on the LLM-docs generation sentinel so the artifacts are
+# always present (a missing/failed generation now fails the check loudly rather
+# than being silently skipped).
+check-local: $(SENTINEL_OMPI_LLM)
+	@$(PYTHON3) $(srcdir)/validate-llm-docs.py \
+	    --srcdir $(srcdir) --llms-dir $(builddir)/llms-build/llms \
+	    --samples $(srcdir)/../specs/llms-friendly-docs/sample-records.jsonl && \
+	rm -rf $(builddir)/llms-det-a $(builddir)/llms-det-b && \
+	SOURCE_DATE_EPOCH=1700000000 $(PYTHON3) $(srcdir)/generate-llm-docs.py \
+	    --srcdir $(srcdir) --builddir $(builddir) \
+	    --outdir $(builddir)/llms-det-a > /dev/null && \
+	SOURCE_DATE_EPOCH=1700000000 $(PYTHON3) $(srcdir)/generate-llm-docs.py \
+	    --srcdir $(srcdir) --builddir $(builddir) \
+	    --outdir $(builddir)/llms-det-b > /dev/null && \
+	if diff -r $(builddir)/llms-det-a $(builddir)/llms-det-b > /dev/null; then \
+	    echo "  CHECK LLM docs: deterministic at fixed SOURCE_DATE_EPOCH"; \
+	    rm -rf $(builddir)/llms-det-a $(builddir)/llms-det-b; \
+	else \
+	    echo "ERROR: LLM docs are not deterministic" >&2; \
+	    rm -rf $(builddir)/llms-det-a $(builddir)/llms-det-b; exit 1; \
+	fi
+
 clean-local:
 	rm -rf $(OUTDIR)
+	rm -rf llms-build llms-build.stamp llms-det-a llms-det-b
+	rm -f $(CODE_OF_CONDUCT_RST)
 	rm -rf prrte-rst-content schizo-ompi-rst-content
 	rm -rf ompi-prrte-objects.inv opal-pmix-objects.inv
 	if test "$(srcdir)" != "$(builddir)"; then \
@@ -1150,7 +1230,7 @@ clean-local:
 # macro.  This hooks into the normal Automake build mechanisms, and
 # will ultimately cause the invocation of the above rule that runs
 # Sphinx to build the HTML and man pages.
-BUILT_SOURCES = $(ALL_MAN_BUILT)
+BUILT_SOURCES = $(CODE_OF_CONDUCT_RST) $(ALL_MAN_BUILT)
 
 endif OPAL_BUILD_DOCS
 
@@ -1166,9 +1246,6 @@ endif
 if OMPI_BUILD_ANY_FORTRAN_BINDINGS
 man1_MANS += $(OMPI_MAN1_FORTRAN_REDIRECTS)
 endif
-if OMPI_WANT_JAVA_BINDINGS
-man1_MANS += $(OMPI_MAN1_JAVA_REDIRECTS)
-endif
 
 man3_MANS = $(OMPI_MAN3_INSTALL_FROM)
 man7_MANS = $(OMPI_MAN7_INSTALL_FROM)
diff --git a/docs/app-debug/index.rst b/docs/app-debug/index.rst
index 91bf934b6c4..b3b18faa3bd 100644
--- a/docs/app-debug/index.rst
+++ b/docs/app-debug/index.rst
@@ -8,7 +8,7 @@ logic errors, uninitialized variables, storage overlays and timing
 problems.
 
 Debugging a parallel application can be further complicated
-by problems that can include additional race conditions and aysynchronous
+by problems that can include additional race conditions and asynchronous
 events, as well as understanding execution of multiple application
 processes running simultaneously.
 
diff --git a/docs/app-debug/lost-output.rst b/docs/app-debug/lost-output.rst
index 57af5cd5f25..9093d9f4dd0 100644
--- a/docs/app-debug/lost-output.rst
+++ b/docs/app-debug/lost-output.rst
@@ -18,7 +18,7 @@ MPI process when it displays the error message.  If the process's
 memory is already corrupted, Open MPI's attempt to allocate memory may
 fail and the process will simply terminate, possibly silently.  When Open
 MPI does not attempt to aggregate error messages, most of its setup
-work is done when the MPI library is initiaized  and no memory is allocated
+work is done when the MPI library is initialized and no memory is allocated
 during the "print the error" routine.  It therefore almost always successfully
 outputs error messages in real time |mdash| but at the expense that you'll
 potentially see the same error message for *each* MPI process that
diff --git a/docs/building-apps/abi-compatibility.rst b/docs/building-apps/abi-compatibility.rst
index 458362ca0ef..325379d97bf 100644
--- a/docs/building-apps/abi-compatibility.rst
+++ b/docs/building-apps/abi-compatibility.rst
@@ -34,7 +34,7 @@ Open MPI v4.x might not execute correctly with Open MPI |ompi_series|.
     compilers (e.g., GNU Fortran >= v4.9), Open MPI v5.0.0 removed the
     names from the MPI interfaces when there is only a single
     subroutine in the interface, and that subroutine name exactly
-    matches the iterface name.  This change is likely to make Open MPI
+    matches the interface name.  This change is likely to make Open MPI
     |ompi_series|'s ``mpi`` module bindings *less* restrictive than
     Open MPI v4.x, but it *may* also have ABI implications, depending
     on your Fortran compiler.
diff --git a/docs/building-apps/deprecation-warnings.rst b/docs/building-apps/deprecation-warnings.rst
index dabf456978d..0a0da77ea78 100644
--- a/docs/building-apps/deprecation-warnings.rst
+++ b/docs/building-apps/deprecation-warnings.rst
@@ -217,7 +217,7 @@ but the usage differs slightly. See the example below.
 	// Create an info object using MPI_Info_create()
 	...
 
-	// Retrieve the the value of a provided key later in the code
+	// Retrieve the value of a provided key later in the code
 	char key[] = "my_key";
 	char value[64];
         int valuelen=64;
@@ -248,7 +248,7 @@ Please refer to the example shown in :ref:`MPI_INFO_GET <label-mpi-info-get>`.
 MPI_Sizeof
 ----------
 
-The ``MPI_SIZEOF`` construct in Fortran has been deprected since there
+The ``MPI_SIZEOF`` construct in Fortran has been deprecated since there
 are standard Fortran language constructs such as ``c_sizeof`` and
 ``storage_size`` that can be used instead.
 
diff --git a/docs/building-apps/removed-mpi-constructs.rst b/docs/building-apps/removed-mpi-constructs.rst
index 4dfa5b77293..d64f7a66780 100644
--- a/docs/building-apps/removed-mpi-constructs.rst
+++ b/docs/building-apps/removed-mpi-constructs.rst
@@ -448,7 +448,7 @@ If we run the above, we get an output of:
 
 The ``MPI_TYPE_RESIZED`` function allows us to take any arbitrary
 datatype and set the lower bound and extent directly (which indirectly
-sets the upper bound), without needing to setup the arrays and
+sets the upper bound), without needing to set up the arrays and
 computing the displacements necessary to invoke
 ``MPI_TYPE_CREATE_STRUCT``.
 
diff --git a/docs/conf.py b/docs/conf.py
index b6e85216a5f..be5a5da9fad 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -14,12 +14,23 @@
 
 # -- Project information -----------------------------------------------------
 
-import os
 import re
 import datetime
 import sphobjinv as soi
 
-year = datetime.datetime.now().year
+# For reproducible builds, derive the copyright year from SOURCE_DATE_EPOCH
+# when it is set (mirroring config/getdate.sh and Sphinx's own format_date,
+# which already honor it for the "Last updated on:" footer); otherwise fall
+# back to the current wall-clock year.  See https://reproducible-builds.org/.
+_source_date_epoch = os.environ.get('SOURCE_DATE_EPOCH')
+try:
+    if _source_date_epoch:
+        year = datetime.datetime.fromtimestamp(
+            int(_source_date_epoch), datetime.timezone.utc).year
+    else:
+        year = datetime.datetime.now().year
+except (ValueError, OverflowError, OSError):
+    year = datetime.datetime.now().year
 
 project = 'Open MPI'
 copyright = f'2003-{year}, The Open MPI Community'
@@ -309,8 +320,20 @@ def _make_intersphinx_mapping(project, name, fallback_base, entries):
 # Hence, listing prrte-rst-content in exclude_patterns means that
 # Sphinx won't complain about the .rst files in that tree that we are
 # not referencing from here in the OMPI docs.
+# Note: llms-src/ holds the committed curated Markdown sources for the
+# LLM-friendly docs, and llms-build/ is the generated LLM artifact staging
+# tree.  Both contain Markdown that must NOT be picked up as Sphinx source
+# documents; they are published into the HTML output by a separate copy step
+# in docs/Makefile.am (not via html_extra_path, which exclude_patterns would
+# also suppress).
+#
+# The html/ and man/ directories are the pre-rendered output copies that ship
+# in distribution tarballs (see html-local / man in Makefile.am).  Now that
+# html/llms/ contains generated Markdown, html/ (and man/, for symmetry) must
+# also be excluded so Sphinx does not re-parse those copies as source.
 exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', 'venv', 'py*/**',
-                    'prrte-rst-content' ]
+                    'tuning-apps/_include', 'prrte-rst-content',
+                    'llms-src', 'llms-build', 'html', 'man' ]
 
 
 # Clarify the language for verbatim blocks (::)
@@ -429,3 +452,48 @@ def _doit(topdir):
    .wy-table-responsive table td,.wy-table-responsive table th{white-space:normal}
    </style>
 """
+
+# -- LLM-friendly documentation artifacts ------------------------------------
+
+# The LLM-friendly artifacts are generated into a build-tree staging directory
+# (<builddir>/llms-build/) by docs/generate-llm-docs.py -- run from the Makefile
+# (the SENTINEL_OMPI_LLM target) for "make" builds, and from
+# .readthedocs-pre-create-environment.sh for Read the Docs builds (which do not
+# run "make").  They are deliberately excluded from Sphinx source discovery
+# (see exclude_patterns above), so we publish them by copying the staging tree
+# into the HTML output in a "build-finished" hook.  Doing the copy here (rather
+# than in the Makefile) means it happens inside sphinx-build and therefore
+# works identically under "make" and on Read the Docs.
+
+def _copy_llm_artifacts(app, exception):
+    import shutil
+
+    if exception is not None or app.builder.name != "html":
+        return
+
+    # The generator writes the staging tree to <builddir>/llms-build, where
+    # <builddir> is the docs build directory.  The Makefile html recipe exports
+    # OMPI_LLM_BUILDDIR so we resolve it explicitly even in an out-of-tree
+    # (VPATH) build where the build dir differs from the source dir.  Fall back
+    # to app.confdir, which equals the build dir under both "make" (the recipe
+    # copies conf.py into builddir and runs sphinx-build there) and Read the
+    # Docs (sphinx-build runs in the source dir, where the generator also ran).
+    builddir = os.environ.get("OMPI_LLM_BUILDDIR", app.confdir)
+    staging = os.path.join(builddir, "llms-build")
+    src_tree = os.path.join(staging, "llms")
+    if not os.path.isdir(src_tree):
+        # Generator was not run (e.g., a bare sphinx-build); nothing to publish.
+        return
+
+    dst_tree = os.path.join(app.outdir, "llms")
+    if os.path.isdir(dst_tree):
+        shutil.rmtree(dst_tree)
+    shutil.copytree(src_tree, dst_tree)
+
+    src_txt = os.path.join(staging, "llms.txt")
+    if os.path.isfile(src_txt):
+        shutil.copy2(src_txt, os.path.join(app.outdir, "llms.txt"))
+
+
+def setup(app):
+    app.connect("build-finished", _copy_llm_artifacts)
diff --git a/docs/developers/autogen.rst b/docs/developers/autogen.rst
index 8239719623e..a740be9ddd1 100644
--- a/docs/developers/autogen.rst
+++ b/docs/developers/autogen.rst
@@ -4,7 +4,7 @@ Running ``autogen.pl``
 You can now run OMPI's top-level ``autogen.pl`` script.  This script
 will invoke the GNU Autoconf, Automake, and Libtool commands in the
 proper order and do a bunch of component discovery and housekeeping to
-setup to run OMPI's top-level ``configure`` script.
+set up to run OMPI's top-level ``configure`` script.
 
 Running ``autogen.pl`` may take a few minutes, depending on your
 system.  It's not very exciting to watch.
diff --git a/docs/developers/building-open-mpi.rst b/docs/developers/building-open-mpi.rst
index ee09d294e20..e53b5a2d767 100644
--- a/docs/developers/building-open-mpi.rst
+++ b/docs/developers/building-open-mpi.rst
@@ -1,9 +1,107 @@
 Building Open MPI
 =================
 
+General
+-------
+
 Once you have run ``autogen.pl`` successfully, you can configure and
 build Open MPI just like end users do with official distribution Open
 MPI tarballs.
 
 See the :doc:`general "Install Open MPI" documentation for more
 details. </installing-open-mpi/index>`
+
+Building Against External OpenPMIx / PRRTE
+------------------------------------------
+
+One thing that developers and/or packagers may need to do is to build
+Open MPI against an external OpenPMIx installation, and/or configure
+Open MPI's ``mpirun`` / ``mpiexec`` launchers to use an external PRRTE
+installation (i.e., installations that were not built from the
+embedded copies inside the Open MPI source tree / Git submodules).
+
+With regards to :doc:`Open MPI's required dependent libraries
+</installing-open-mpi/required-support-libraries>` (Hwloc, Libevent,
+OpenPMIx, and PRRTE), it generally is simplest to build Open MPI in
+one of two ways:
+
+#. Build and use all the **internal** copies of Open MPI's required
+   dependent libraries.
+
+   * Specifically: use the Hwloc, Libevent, OpenPMIx, and PRRTE source
+     trees that are bundled in with Open MPI's source code.
+
+#. Build and use all **external** copies of Open MPI's required
+   dependent libraries.
+
+   * Specifically: ignore the Hwloc, Libevent, OpenPMIx, and PRRTE source
+     trees that are bundled in with Open MPI's source code, and,
+     instead, build Open MPI against already-installed Hwloc,
+     Libevent, and OpenPMIx libraries, and configure Open MPI's
+     launchers to use an already-installed PRRTE.
+
+Other variations are possible, but can get tricky and complicated
+because Open MPI, the OpenPMIx library that it uses, Hwloc, and
+Libevent can be loaded into the same process.  They are therefore not
+recommended unless you understand the run-time linker consequences.
+
+Some facts that are relevant to know when building against an external
+OpenPMIx / PRRTE:
+
+1. Open MPI and the OpenPMIx library that Open MPI links against must
+   be built against the **same** installation of Hwloc and Libevent.
+   Meaning:
+
+   * Assumedly the external OpenPMIx was built against external Hwloc
+     and Libevent.  Open MPI **must** compile and link against the
+     **same** Hwloc and Libevent that the external OpenPMIx was built
+     against.
+
+     .. admonition:: Critical
+        :class: Danger
+
+        Open MPI and the OpenPMIx library that it links against must
+        use the same Hwloc and Libevent libraries at run time (e.g.,
+        they must resolve to the same run-time loadable libraries at
+        run time).
+
+        .. important:: This statement applies regardless of whether
+                       Open MPI -- and/or the other libraries -- are
+                       built as static or dynamically-loadable
+                       libraries.
+
+   * Unless you really know what you are doing, this usually means
+     building and installing Open MPI against the same installation
+     tree(s) of Hwloc and Libevent that OpenPMIx used to build itself.
+
+     For example, consider an environment where you install Hwloc,
+     Libevent, OpenPMIx, and PRRTE via the operating system's package
+     manager.  Assuming that the package-manager install of OpenPMIx
+     was built against the package-manager-provided Hwloc and
+     Libevent, then Open MPI will *also* need to be built against the
+     package-manager-provided Hwloc and Libevent.  To build Open MPI
+     this way, you may need to install the package manager's
+     "developer" Hwloc, Libevent, and OpenPMIx packages.
+
+1. PRRTE and the OpenPMIx library that PRRTE uses must be built
+   against the **same** installation of Hwloc and Libevent.
+
+   This is a separate requirement from Open MPI's requirement above:
+   Open MPI does not link against PRRTE, and MPI applications do not
+   load ``libprrte``.  Therefore, PRRTE's Hwloc, Libevent, and
+   OpenPMIx dependencies do not have to match Open MPI's dependencies
+   merely because Open MPI uses PRRTE as a launcher.
+
+1. Open MPI and PRRTE do **not** have to use the same OpenPMIx
+   installation.
+
+   PMIx supports cross-version operations, so Open MPI and PRRTE can
+   use different OpenPMIx installations, and those installations do
+   not need to be the same OpenPMIx version.
+
+   If Open MPI and PRRTE do use the **same** OpenPMIx installation,
+   then the requirements above mean that Open MPI, PRRTE, OpenPMIx,
+   Hwloc, and Libevent will all use the same Hwloc and Libevent
+   installations.  However, this is a consequence of sharing one
+   OpenPMIx installation; it is not a requirement that Open MPI and
+   PRRTE share one OpenPMIx installation.
diff --git a/docs/developers/index.rst b/docs/developers/index.rst
index 6e82d253d37..ca98bea2925 100644
--- a/docs/developers/index.rst
+++ b/docs/developers/index.rst
@@ -23,3 +23,4 @@ probably don't need to read this section.
    sphinx
    rst-for-markdown-expats.rst
    bindings
+   llm-friendly-docs
diff --git a/docs/developers/llm-friendly-docs.rst b/docs/developers/llm-friendly-docs.rst
new file mode 100644
index 00000000000..0e64250752b
--- /dev/null
+++ b/docs/developers/llm-friendly-docs.rst
@@ -0,0 +1,389 @@
+LLM-friendly documentation artifacts
+====================================
+
+In addition to the human-facing HTML and Unix man pages, the Open MPI
+documentation build publishes machine-readable, LLM-friendly artifacts for
+the public MPI APIs (C, ``mpif.h``, ``use mpi``, and ``use mpi_f08``). They
+are indexed from a top-level ``llms.txt`` and published under ``llms/`` in
+each documentation version (for example,
+``https://docs.open-mpi.org/en/<version>/llms.txt``, where ``<version>`` is
+the Read the Docs version slug, such as ``v6.1.x`` or ``main``).
+
+The intent is to give LLMs, retrieval systems, and coding assistants concise,
+authoritative, version-correct MPI API information --- a signature, its
+parameters, the right language interface, and a link back to the human docs ---
+*without* scraping themed HTML or guessing from filenames, and *without*
+creating a second hand-maintained API reference that could drift from the real
+documentation.
+
+This page is for Open MPI developers and release managers who maintain these
+artifacts. It records the design intent and the day-to-day maintenance rules;
+the full design record (every field, every alternative considered) lives in
+``specs/llms-friendly-docs/spec.md`` in the source tree.
+
+Background: the llms.txt convention
+-----------------------------------
+
+``llms.txt`` is a convention proposed by Jeremy Howard in September 2024
+(`llmstxt.org <https://llmstxt.org/>`_) for exposing LLM-friendly content at a
+well-known location --- a Markdown file at the site root (``/llms.txt``),
+alongside the established ``robots.txt`` and ``sitemap.xml``. The bare
+convention is an *index*: an H1 project name, a short summary, and
+H2-delimited lists of Markdown links, optionally with companion ``.md``
+versions of HTML pages.
+
+`Read the Docs supports this convention
+<https://docs.readthedocs.com/platform/stable/reference/llms-txt.html>`_: it
+does **not** auto-generate the file, but if a built, public, active default
+version contains an ``llms.txt`` in its HTML output, Read the Docs serves it at
+the project root.
+
+Open MPI **extends** the convention rather than merely conforming to it. A bare
+link index is not enough for a tool that needs to answer signature, parameter,
+and interface questions programmatically, so alongside the ``llms.txt`` index
+Open MPI also publishes a structured JSONL API catalog, language-specific
+Markdown corpora, per-symbol Markdown pages, and a machine-readable manifest
+(see `What is generated`_). The ``llms.txt`` index itself follows the spirit of
+the convention (an H1 name, a summary, and link sections) but adds prose that an
+automated consumer needs --- most importantly, a description of the URL scheme
+for *other* versions (see `Read the Docs and the version-neutral llms.txt`_).
+
+Design principles
+-----------------
+
+Five cross-cutting principles explain most of the decisions below. When in
+doubt, preserve these properties.
+
+* **The existing RST man pages and the MPI Forum JSON binding metadata are the
+  only source of truth.** A core goal is to *avoid a second hand-maintained
+  API reference*. The generated artifacts are derived, never authored: the set
+  of documented procedures comes from the ``man-openmpi/man3/MPI_*.3.rst`` man
+  pages and the command corpus from the ``man-openmpi/man1/*.rst`` pages, while
+  standard-API signatures/parameters come from the MPI Forum metadata
+  (``mpi-standard-apis.json`` via the embedded ``pympistandard`` library). This
+  is why adding a new API is a matter of adding a man page, not editing the
+  generator (see `Updating the documentation when APIs change`_), and why the
+  curated examples reuse the top-level ``examples/`` tree instead of copying it.
+
+* **Each artifact's content hash is a pure function of its semantic content.**
+  Build-identity fields (``git_commit``, ``git_describe``, ``generated_at``)
+  live **only** in the manifest --- never in the catalog records, corpora, or
+  per-symbol pages. If a commit hash were embedded in every record, every
+  artifact's hash would change on every repository commit, even one that touches
+  no documentation, making the manifest's per-artifact hashes useless as change
+  detectors. Keeping build identity in one place gives consumers the clean
+  property *"hash changed* ⇔ *documentation content changed."* This is also why
+  the versioned ``llms.txt`` is timestamp-free (it carries the version, not a
+  generation time) and why the manifest is the one artifact that does not
+  inventory itself.
+
+* **Reproducible under Open MPI's existing knob.** The build fits the project's
+  established reproducible-builds model rather than inventing a new one: the
+  semantic artifacts contain no wall-clock data and are byte-identical across
+  reruns at a given commit; only the manifest's ``generated_at`` varies, and it
+  is derived from ``SOURCE_DATE_EPOCH`` when set (see `Reproducibility and the
+  per-release manifest`_).
+
+* **The schemas are simultaneously the published contract and the CI
+  validator.** ``docs/llms-src/*.schema.json`` are shipped as artifacts *and*
+  used directly by ``make check``, so the contract and the check cannot drift.
+  They are "open" objects (no ``additionalProperties: false``) so that an
+  additive field never breaks a consumer validating against an older cached
+  copy of the schema (see `Schema evolution`_).
+
+* **The artifacts ride inside the HTML output tree.** Rather than a parallel
+  distribution mechanism, the ``llms/`` tree and ``llms.txt`` are copied into
+  the Sphinx HTML output, so they inherit the existing HTML packaging,
+  installation, and tarball machinery for free, and the link strategy follows
+  the build type (see `How they are built`_ and `Link strategy: relative vs.
+  absolute links`_).
+
+What is generated
+-----------------
+
+* ``llms/openmpi-mpi-api.jsonl`` --- one JSON record per documented MPI
+  procedure (standard, extension, and deprecated/removed). A record is
+  per *procedure*, not per page.
+* ``llms/openmpi-mpi-api.md`` and the four per-interface corpora (C, ``mpif.h``,
+  ``use mpi``, ``use mpi_f08``). ``mpif.h`` and ``use mpi`` share the same
+  ``f90`` signature and differ only in the access preamble, so those two
+  corpora are near-duplicates by design; they are kept separate for audience
+  clarity and possible future divergence.
+* ``llms/man-openmpi/man3/MPI_<name>.3.md`` --- one Markdown page per man page,
+  1:1 with the human man pages so canonical URLs line up. Overview/non-procedure
+  pages (e.g. ``MPI_T.3``, ``MPI_Errors.3``) get a Markdown page but no JSONL
+  record.
+* ``llms/man-openmpi/man1/<command>.1.md`` --- one Markdown page per command man
+  page (``mpirun``, ``ompi_info``, the wrapper compilers, ...). These document
+  Open MPI *commands*, not MPI APIs, so they are a Markdown corpus only ---
+  there are no JSONL catalog records for them.
+* ``llms/openmpi-docs-manifest.json`` --- the artifact inventory; the only
+  artifact that carries build identity (git commit/describe and
+  ``generated_at``).
+* The curated ``llms/openmpi-mpi-interface-guide.md``,
+  ``llms/openmpi-mpi-examples.md``, and
+  ``llms/openmpi-runtime-introspection.md`` (hand-written sources under
+  ``docs/llms-src/``), plus the two published ``*.schema.json`` files. The
+  runtime-introspection guide tells a consumer how to query an *installed*
+  Open MPI with ``ompi_info`` --- its version, build configuration, available
+  MCA components, and the run-time MCA parameters those components expose. That
+  surface is **installation-specific** (it depends on which components were
+  built), so it is intentionally *not* snapshotted into the corpus; an
+  ``ompi_info --all --parsable`` snapshot would bake in one machine's paths and
+  component set, immediately drift, and could not be produced at all on Read the
+  Docs (which builds the docs without a full Open MPI install). The corpus
+  therefore points consumers at the live, self-describing command output
+  instead.
+
+How they are built
+------------------
+
+``docs/generate-llm-docs.py`` produces the artifacts into a build-tree staging
+directory (``docs/llms-build/``). It is run in both documentation build paths,
+just like the man-page bindings generator: from a sentinel target in
+``docs/Makefile.am`` (after the man3 bindings, before Sphinx) for ``make``
+builds, and from ``.readthedocs-pre-create-environment.sh`` for Read the Docs
+builds (which run ``sphinx-build`` directly and never run ``make``). Shared MPI
+metadata logic (binding rendering, ``VERSION`` parsing, build identity) lives in
+``docs/ompi_docs_common.py``, which is also used by the man-page bindings
+generator. No separate command is needed: building the docs builds the LLM
+artifacts.
+
+A ``build-finished`` hook in ``docs/conf.py`` then copies the staging tree
+(``llms-build/llms`` → ``<output>/llms`` and ``llms-build/llms.txt`` →
+``<output>/llms.txt``) into the Sphinx HTML output. The copy lives in a Sphinx
+hook --- rather than ``html_extra_path`` or a Makefile step --- for two
+reasons: (1) the staged Markdown is deliberately excluded from Sphinx source
+discovery (``exclude_patterns``), which would *also* suppress an
+``html_extra_path`` entry pointing at it; and (2) the hook runs inside
+``sphinx-build``, so publication works identically under ``make`` and on Read
+the Docs. Because the artifacts ride inside the HTML output tree, the existing
+``html-local`` / ``EXTRA_DIST`` (tarballs), ``install-data-hook`` (install), and
+``uninstall-hook`` (uninstall) machinery handles them with no new rules.
+
+Link strategy: relative vs. absolute links
+-------------------------------------------
+
+Every generated link --- in ``llms.txt``, in the JSONL records' ``urls``, in the
+manifest ``url`` fields, and in the per-symbol/man1 page Canonical-HTML headers
+--- follows the build type:
+
+* A **local build from git, or a release tarball,** produces the artifacts for a
+  *local* tool that reads the files straight off disk. There is no
+  ``docs.open-mpi.org`` site in play, so every link is made **relative to the
+  file that contains it**. The result is a self-contained, portable tree that
+  resolves no matter where it lives (or is unpacked from a tarball), and which
+  needs no network access to follow internal links.
+* A **Read the Docs build** publishes under ``https://docs.open-mpi.org/en/<slug>/``,
+  so every link is **absolute** and uses that published version slug
+  (``.../en/main/...`` for the ``main`` branch, ``.../en/v6.1.x/...`` for a
+  release branch, ``.../en/v6.1.0/...`` for a tagged release). Absolute links
+  mean a record copied *out* of the published site --- into a vector store, a
+  prompt, a cache --- still resolves back to the correct version's
+  documentation.
+
+The base URL is resolved in this order: an explicit ``--url-base`` /
+``OMPI_LLM_URL_BASE`` override; then ``READTHEDOCS_CANONICAL_URL`` /
+``READTHEDOCS_VERSION`` (set by Read the Docs); otherwise relative. This logic
+lives in the ``LinkMaker`` class in ``docs/generate-llm-docs.py``. The one
+exception: the version-slug *scheme-documentation* URLs printed inside
+``llms.txt`` (the ``.../en/VERSION_SLUG/`` examples) are always literal absolute
+``docs.open-mpi.org`` text, even in a local build, so a local consumer still
+learns where the published versions live.
+
+Because both passes (local and Read the Docs) each pick one strategy and hold it
+constant, the determinism check (which generates twice and diffs) is unaffected.
+
+Read the Docs and the version-neutral llms.txt
+----------------------------------------------
+
+Read the Docs serves the version-neutral ``https://docs.open-mpi.org/llms.txt``
+by serving **the default version's own** ``llms.txt`` at the site root. There is
+no separate, hand-maintained top-level index file: the root URL is simply
+whichever ``llms.txt`` the current default version produced. Each documentation
+version emits exactly one self-describing ``llms.txt`` for itself.
+
+This RTD behavior directly drove the *content* of ``llms.txt``. Because the file
+served at the root is just some version's file --- and the default version may
+be a series that does not even carry these artifacts yet --- ``llms.txt`` cannot
+assume it is authoritative for the whole project. So it **self-describes the
+version-slug URL scheme**:
+
+* it states the ``https://docs.open-mpi.org/en/VERSION_SLUG/`` scheme and how to
+  read a slug (``main`` = the main-branch build; ``vA.B.x`` = a release branch;
+  ``vA.B.C`` = a specific tagged release), worded so an LLM that wants a
+  *different* version can construct the URL itself;
+* it notes that documentation for Open MPI versions older than v5.0.0 is not
+  published in this format, and points at the legacy README/FAQ/doc pages;
+* for a Read the Docs ``main`` build it uses **dual attribution** --- naming both
+  the ``main`` slug and the ``vA.B.x`` series that build currently represents ---
+  because the same file is both "the development tip" and "the current
+  pre-release series."
+
+If a future need arises for the root ``/llms.txt`` to be something other than the
+default version's copy, Read the Docs exact redirects can point ``/llms.txt`` at
+a chosen versioned path; no generator change would be required.
+
+Validation
+----------
+
+``make check`` builds the artifacts if they are not already present and then
+runs ``docs/validate-llm-docs.py``, which validates the catalog and manifest
+against the published JSON Schemas (``docs/llms-src/*.schema.json``), checks
+cross-field invariants (for example, that a record's ``languages`` equals the
+distinct set of its ``bindings[].language``) and manifest integrity (hashes,
+byte sizes, coverage), confirms the generated Markdown is free of unresolved RST
+(``.. include::`` directives, ``:ref:`` roles, Sphinx-only substitutions),
+confirms the versioned ``llms.txt`` carries no generation timestamp, verifies the
+committed sample records (``specs/llms-friendly-docs/sample-records.jsonl``)
+match the generated catalog, and confirms the generator is deterministic at a
+fixed ``SOURCE_DATE_EPOCH``.
+
+Reproducibility and the per-release manifest
+--------------------------------------------
+
+The artifacts are regenerated by the normal documentation build, so there is no
+separate regeneration step for release managers, and no separate command for
+developers: ``make`` (or a Read the Docs build) regenerates everything,
+including the manifest, every time.
+
+The manifest (``llms/openmpi-docs-manifest.json``) is rebuilt on every build and
+is the single place that carries build identity: ``git_commit``,
+``git_describe``, ``generated_at``, the Open MPI version/series (from the
+top-level ``VERSION`` file), the Read the Docs slug when present, and one entry
+per artifact (path, URL, media type, SHA-256, byte size, estimated token count,
+and the symbols/languages it covers). It does **not** inventory itself --- a file
+cannot record its own hash and size without changing them. Consumers do not need
+a separately incremented "docs release number": they compare the manifest's
+identity fields and per-artifact hashes. If, say, the ``v6.1.x`` branch gets a
+documentation fix before ``v6.1.1`` ships, the Open MPI version may be unchanged
+but the git identity and the hashes of the *affected* artifacts change, while
+everything else stays byte-identical.
+
+For a reproducible release tarball, set ``SOURCE_DATE_EPOCH`` (as already
+documented for reproducible Open MPI builds): the generator honors it for the
+manifest ``generated_at`` timestamp, exactly as ``config/getdate.sh`` and
+Sphinx's ``format_date`` do for the rest of the docs build. With
+``SOURCE_DATE_EPOCH`` set, the whole documentation build (HTML, man pages, and
+LLM artifacts) is reproducible. In a from-tarball build with no ``.git`` and no
+``SOURCE_DATE_EPOCH``, the generator degrades gracefully rather than failing:
+the git fields become ``unknown``/omitted and ``generated_at`` falls back to the
+build date, mirroring ``config/opal_get_version.sh``. Distribution tarballs ship
+the already-rendered ``llms/`` tree inside ``html/``, so installing or packaging
+them never requires Sphinx; Sphinx is needed only to *regenerate* them in a
+developer clone.
+
+Schema evolution
+----------------
+
+The catalog and manifest each conform to a published JSON Schema that doubles as
+the CI validator.
+
+* Changes are **additive within a** ``schema_version``: new fields must be
+  optional, and a field may be marked deprecated (still emitted) for one Open
+  MPI release series before removal. Never remove, rename, repurpose, or change
+  the meaning of an existing field without bumping the schema version. The
+  published schemas use open objects so an additive field does not break a
+  consumer validating against an older cached schema.
+* ``schema_version`` / ``artifact_schema_version`` are bumped **only on a
+  breaking change**, a decision owned by the documentation maintainers. The
+  ``schema_version`` is independent of the Open MPI release number, so the
+  schema can stay fixed across many releases.
+* A schema-version bump or notable field change gets a changelog entry under
+  ``docs/release-notes/changelog/``. Routine regeneration (content that flows
+  automatically from changed RST or metadata) does not.
+
+Updating the documentation when APIs change
+-------------------------------------------
+
+The generated artifacts cannot drift, because they regenerate from the RST man
+pages and the MPI Forum JSON binding metadata. The practical consequence is that
+**you update
+the LLM docs by updating the ordinary documentation**, not by editing the
+generator.
+
+**Adding or changing an MPI API function.** When a new MPI Standard function is
+added (for example, when a new MPI version lands), the LLM artifacts pick it up
+automatically *once its man page exists*:
+
+#. Add or edit ``docs/man-openmpi/man3/MPI_<Name>.3.rst`` --- the same
+   hand-written man page that produces the human HTML/man output. This man page
+   is what makes the function "documented"; both the man3 binding generator and
+   the LLM generator enumerate the man3 ``.rst`` files (via ``os.listdir``), so
+   a function that is in the metadata but has no ``.rst`` page is silently *not*
+   documented anywhere.
+#. Add the page to the explicit ``OMPI_MAN3`` list in ``docs/Makefile.am``. The
+   generators auto-discover the file and the ``RST_SOURCE_FILES`` wildcard
+   already makes it a rebuild dependency, but the *installation* list is
+   explicit (Automake installs man pages by name), so a new page must be listed
+   there to be installed.
+#. For standard APIs there is **nothing to author for the bindings**: the C,
+   ``mpif.h``/``use mpi``, and ``use mpi_f08`` signatures (and any large-count
+   "embiggened" variant) are rendered from ``pympistandard`` +
+   ``mpi-standard-apis.json``.
+#. If one man page documents several procedures, mark them with a
+   ``.. mpi-bindings: MPI_Foo, MPI_Bar`` comment line so each co-documented
+   procedure gets its own bindings, catalog record, and ``documented_with``
+   linkage.
+
+No change to ``generate-llm-docs.py``, the schemas, or the validator is needed
+for a routine new function: a new ``.rst`` automatically yields a new man page,
+a per-symbol Markdown page, and a JSONL catalog record.
+
+**Open MPI extensions** (``MPIX_*``, ``OMPI_*``) are not in ``pympistandard``, so
+their signatures are taken **verbatim** from the RST ``SYNTAX`` block and their
+structured parameter fields are best-effort (``unknown`` where they cannot be
+extracted reliably). The catalog's ``kind`` field lets consumers tell standard
+records from extension records.
+
+**Upgrading the MPI Standard metadata** (for example, replacing the 4.1
+``apis.json`` with a 5.0 one): update ``docs/mpi-standard-apis.json`` (it is a
+symlink to the versioned ``mpi-standard-<ver>-apis.json``). Note that
+``load_pympistandard`` calls ``use_api_version(1, ...)`` --- the ``1`` is
+``pympistandard``'s *data-format* version, **not** the MPI version. A new MPI
+metadata file is only loadable if the vendored ``3rd-party/pympistandard`` can
+parse that format; if the MPI Forum bumped the JSON format, update the vendored
+library in lockstep and smoke-test that the new JSON loads.
+
+**Coverage gaps are currently silent.** There is no check that flags a procedure
+present in the metadata but missing a man page (or vice versa); such a procedure
+is simply absent from the artifacts. (The spec envisions a lightweight CI
+"drift hint" for this; it is not yet implemented.) When adding a batch of new
+functions, cross-check that every intended function actually has an
+``MPI_*.3.rst`` page.
+
+**Curated docs and samples.** The generated artifacts cannot drift, but the
+curated ``docs/llms-src/`` files (interface guide, examples, and
+runtime-introspection guide) can. A pull request that changes public MPI
+documentation should also update the affected curated files when relevant ---
+for example, the runtime-introspection guide if the ``ompi_info`` interface or
+the MCA parameter-setting conventions change (this expectation is also recorded
+in the top-level ``AGENTS.md``). When the curated examples or a schema change, regenerate
+``specs/llms-friendly-docs/sample-records.jsonl`` so ``make check`` continues to
+pass.
+
+Verifying publication
+---------------------
+
+After a merge that affects the artifacts, confirm Read the Docs published them
+for the version you merged to: fetch that version's ``llms.txt`` (for example
+``https://docs.open-mpi.org/en/main/llms.txt`` for the ``main`` branch) and one
+versioned artifact (for example the manifest,
+``.../en/<version>/llms/openmpi-docs-manifest.json``) and confirm they resolve
+and parse. Because the version-neutral ``https://docs.open-mpi.org/llms.txt``
+follows Read the Docs' *default* version --- which may not be the version you
+just merged --- always spot-check the specific version slug you published.
+
+Alternatives considered and deferred
+------------------------------------
+
+For the historical record (details in ``specs/llms-friendly-docs/spec.md``):
+
+* **OpenSHMEM** public APIs can later reuse this same artifact model, but support
+  is **deferred until there is concrete demand**; this effort covers MPI only.
+* An ``llms-full.txt`` single-payload entry point, compressed downloadable
+  bundles, and stable redirects for renamed artifacts were each considered and
+  **dropped** --- the aggregate Markdown corpora, the release tarballs plus the
+  manifest, and ad hoc Read the Docs redirects respectively make them
+  unnecessary. The JSON Schema files, by contrast, were promoted *into* scope as
+  the shared contract/validator.
diff --git a/docs/developers/prerequisites.rst b/docs/developers/prerequisites.rst
index b4971635b52..18d4ab531a4 100644
--- a/docs/developers/prerequisites.rst
+++ b/docs/developers/prerequisites.rst
@@ -8,8 +8,7 @@ Although it should probably be assumed, you'll need a C compiler that
 supports C11.
 
 You'll also need a Fortran compiler if you want to build the Fortran
-MPI bindings (the more recent the Fortran compiler, the better), and a
-Java compiler if you want to build the (unofficial) Java MPI bindings.
+MPI bindings (the more recent the Fortran compiler, the better).
 
 GNU Autotools
 -------------
diff --git a/docs/developers/rst-for-markdown-expats.rst b/docs/developers/rst-for-markdown-expats.rst
index af09f7dee33..e4531f62822 100644
--- a/docs/developers/rst-for-markdown-expats.rst
+++ b/docs/developers/rst-for-markdown-expats.rst
@@ -152,7 +152,7 @@ Multi-line code/fixed-width font
     case, the example code block will be rendered in the bulleted
     item.
 
-Whereas this parargraph and code block will be outside of the
+Whereas this paragraph and code block will be outside of the
 above bulleted list:
 
 .. code-block:: sh
@@ -243,12 +243,11 @@ Including files
   .. code-block:: rst
 
      .. include:: features-extensions.rst
-     .. include:: features-java.rst
 
-  Those directives include those 2 files right here in this RST file.
+  That directive includes that file right here in this RST file.
 
   .. important:: Chapter/section/subsection delimiters will be
-                 continued in those files as part of rendering this
+                 continued in that file as part of rendering this
                  file.
 
 Hyperlinks to URLs
diff --git a/docs/developers/source-code.rst b/docs/developers/source-code.rst
index a2108e62446..484cd88a183 100644
--- a/docs/developers/source-code.rst
+++ b/docs/developers/source-code.rst
@@ -226,8 +226,7 @@ identical) directory structures under them:
 There are other top-level directories in each of the sub-projects,
 each having to do with specific logic and code for that project.  For
 example, the MPI API implementations can be found under
-``ompi/mpi/LANGUAGE``, where ``LANGUAGE`` is ``c``, ``fortran``, or
-``java``.
+``ompi/mpi/LANGUAGE``, where ``LANGUAGE`` is ``c`` or ``fortran``.
 
 The layout of the ``mca`` trees are strictly defined.  They are of the
 form:
diff --git a/docs/developers/sphinx.rst b/docs/developers/sphinx.rst
index 0e0b2c7231e..74a53b9625b 100644
--- a/docs/developers/sphinx.rst
+++ b/docs/developers/sphinx.rst
@@ -131,7 +131,7 @@ under ``$HOME/Library/Python/PYTHON_VERSION/bin/sphinx-build``).
 Running Sphinx
 --------------
 
-Open MPI's build environment is setup to invoke Sphinx automatically;
+Open MPI's build environment is set up to invoke Sphinx automatically;
 you should not need to invoke Sphinx manually.
 
 .. important:: You will need to ensure that Sphinx is in your ``PATH``
diff --git a/docs/features/extension-affinity.rst b/docs/features/extension-affinity.rst
new file mode 100644
index 00000000000..ca8450e062d
--- /dev/null
+++ b/docs/features/extension-affinity.rst
@@ -0,0 +1,49 @@
+.. _ompi-features-extension-affinity-label:
+
+Affinity extension
+==================
+
+Overview
+--------
+
+The ``affinity`` extension provides a single Open MPI-specific
+function, :ref:`OMPI_Affinity_str(3) <ompi_affinity_str>`.  Given a
+format selector, it fills in three human-readable strings describing:
+
+* where Open MPI bound the calling process at launch time (or that it
+  was not bound);
+* where the process is *currently* bound (or that it is unbound); and
+* which processors exist on the local host.
+
+The strings can be requested either as resource descriptions (for
+example, ``socket 0, core 0``) or as an ASCII-art layout of the
+machine (for example, ``[. B][. .]``).  This is an Open
+MPI-specific convenience API for applications that want to introspect
+their own binding; it is not part of the MPI standard.
+
+When it is built
+----------------
+
+The ``affinity`` extension has no build-time prerequisites, so it is
+built by default on every platform.  Like all extensions, it can be
+excluded by configuring with ``--disable-mpi-ext``, or by naming an
+explicit list that omits it (for example,
+``--enable-mpi-ext=cuda,rocm``).  See :ref:`the extensions overview
+<ompi-features-extensions-label>` for the full set of
+``--enable-mpi-ext`` / ``--disable-mpi-ext`` options.
+
+Availability at run time
+------------------------
+
+Because the extension has no external dependencies, it is available at
+run time whenever it was compiled in.  Applications should still guard
+their use of it with the preprocessor macro
+``OMPI_HAVE_MPI_EXT_AFFINITY``, which ``<mpi-ext.h>`` defines to ``1``
+when the extension is present.  This keeps application code portable
+across Open MPI builds that omitted the extension and across other MPI
+implementations.
+
+Functions
+---------
+
+* :ref:`OMPI_Affinity_str(3) <ompi_affinity_str>`
diff --git a/docs/features/extension-example.rst b/docs/features/extension-example.rst
new file mode 100644
index 00000000000..36cdc4c2f17
--- /dev/null
+++ b/docs/features/extension-example.rst
@@ -0,0 +1,50 @@
+.. _ompi-features-extension-example-label:
+
+Example extension
+=================
+
+Overview
+--------
+
+The ``example`` extension is **non-functional**: it exists solely as a
+worked template for developers who want to create a new Open MPI
+extension.  It defines a demonstration API named ``OMPI_Progress()`` in
+all four MPI binding types (C, the Fortran ``mpif.h`` bindings, the
+Fortran ``mpi`` module, and the Fortran ``mpi_f08`` module), showing
+how each piece is wired into the publicly-available ``mpi-ext.h`` header
+and the ``mpi_ext`` / ``mpi_f08_ext`` Fortran modules.
+
+It is not intended for use by applications.  Anyone writing a real
+extension should read the heavily-commented source and the
+``README.md`` in the source tree
+(``ompi/mpiext/example/README.md``), which walk through the required
+directory layout, file naming, and ``configure.m4`` conventions.
+
+When it is built
+----------------
+
+Unlike the other extensions, ``example`` is not built as part of a
+normal build.  Because it is a developer template, it is only compiled
+when it is explicitly requested at configure time:
+
+.. code-block:: sh
+
+   shell$ ./configure --enable-mpi-ext=example <other configure params>
+
+See :ref:`the extensions overview <ompi-features-extensions-label>` for
+the full ``--enable-mpi-ext`` syntax.
+
+Availability at run time
+------------------------
+
+When the extension is compiled in, ``<mpi-ext.h>`` defines the
+preprocessor macro ``OMPI_HAVE_MPI_EXT_EXAMPLE`` to ``1``.  Since the
+extension is a demonstration only, applications have no reason to depend
+on it; it is documented here for completeness because it appears in the
+list of available extensions.
+
+Functions
+---------
+
+This extension provides only a demonstration ``OMPI_Progress()`` entry
+point and has no manual pages.
diff --git a/docs/features/extension-shortfloat.rst b/docs/features/extension-shortfloat.rst
new file mode 100644
index 00000000000..44ff053a2d4
--- /dev/null
+++ b/docs/features/extension-shortfloat.rst
@@ -0,0 +1,57 @@
+.. _ompi-features-extension-shortfloat-label:
+
+Short float extension
+=====================
+
+Overview
+--------
+
+The ``shortfloat`` extension provides MPI datatypes corresponding to
+short / half-precision floating point language types.  Depending on
+which types the compiler supports, it defines some or all of:
+
+* ``MPIX_C_FLOAT16`` |mdash| for the C type ``_Float16`` (ISO/IEC TS
+  18661-3:2015).  This name and meaning match MPICH.
+* ``MPIX_SHORT_FLOAT`` |mdash| for the C/C++ type ``short float``.
+* ``MPIX_C_SHORT_FLOAT_COMPLEX`` |mdash| for the C type ``short float
+  _Complex``.
+* ``MPIX_CXX_SHORT_FLOAT_COMPLEX`` |mdash| for the C++ type
+  ``std::complex<short float>``.
+
+These datatypes were proposed for (but not accepted into) the MPI
+standard, so they carry the ``MPIX_`` prefix.  See the extension's
+``README.md`` in the source tree
+(``ompi/mpiext/shortfloat/README.md``) and `MPI Forum issue 65
+<https://github.com/mpi-forum/mpi-issues/issues/65>`_ for background.
+
+Because this extension only adds datatype handles (constants), it does
+not provide any functions, and therefore has no manual pages.
+
+When it is built
+----------------
+
+The ``shortfloat`` extension is built by default, but *only* when the
+compiler provides a suitable short / half-precision floating point
+type.  Specifically, Open MPI's ``configure`` builds it when either:
+
+* the compiler natively supports a ``short float`` type; or
+* Open MPI can provide an equivalent 16-bit type (``opal_short_float_t``,
+  typically mapped to ``_Float16``).
+
+If neither is available, the extension is silently omitted |mdash| there
+is no dedicated configure option to force it on, since it depends
+entirely on compiler support.  As with all extensions, it can be
+excluded explicitly with ``--disable-mpi-ext`` or by omitting it from
+an explicit ``--enable-mpi-ext=LIST``.  See :ref:`the extensions
+overview <ompi-features-extensions-label>` for details.
+
+Availability at run time
+------------------------
+
+When the extension is compiled in, ``<mpi-ext.h>`` defines the
+preprocessor macro ``OMPI_HAVE_MPI_EXT_SHORTFLOAT`` to ``1``.
+Applications should test this macro before using any of the ``MPIX_``
+datatypes above, both because the extension may have been omitted (if
+the compiler lacked a short float type) and to remain portable to other
+MPI implementations.  Note that the individual datatype handles that are
+defined depend on which language types were available at build time.
diff --git a/docs/features/extensions.rst b/docs/features/extensions.rst
index 592d56e7687..adf9dcd6ae8 100644
--- a/docs/features/extensions.rst
+++ b/docs/features/extensions.rst
@@ -1,4 +1,4 @@
-.. _ompi-features-extentions-label:
+.. _ompi-features-extensions-label:
 
 Open MPI extensions
 ===================
@@ -20,37 +20,74 @@ to MPI applications.
 Available extensions
 --------------------
 
-The following extensions are included in this version of Open MPI:
-
-#. ``shortfloat``: Provides MPI datatypes ``MPIX_C_FLOAT16``,
-   ``MPIX_SHORT_FLOAT``, ``MPIX_SHORT_FLOAT``, and
-   ``MPIX_CXX_SHORT_FLOAT_COMPLEX`` if corresponding language types are
-   available. See ``ompi/mpiext/shortfloat/README.txt`` for details.
-#. ``affinity``: Provides the ``OMPI_Affinity_str()`` API, which returns
-   a string indicating the resources which a process is bound. For
-   more details, see its man page.
-#. ``cuda``: When the library is compiled with CUDA-aware support, it
-   provides two things.  First, a macro
-   ``MPIX_CUDA_AWARE_SUPPORT``. Secondly, the function
-   ``MPIX_Query_cuda_support()`` that can be used to query for support.
-#. ``example``: A non-functional extension; its only purpose is to
-   provide an example for how to create other extensions.
-#. ``ftmpi``: An implementation of the User Level Fault Mitigation
-   (ULFM) proposal.  :ref:`See its documentation section <ulfm-label>`
-   for more details.
+The following extensions are included in this version of Open MPI.
+Follow the link on each name for a full description of what it
+provides, when it is built, when it is available at run time, and the
+functions it offers:
+
+* :doc:`affinity </features/extension-affinity>`: Provides the
+  ``OMPI_Affinity_str()`` API, which returns human-readable strings
+  describing how the calling process is bound to processor resources.
+
+* :doc:`cuda </tuning-apps/accelerators/cuda>`: Provides the
+  ``MPIX_CUDA_AWARE_SUPPORT`` compile-time macro and the
+  ``MPIX_Query_cuda_support()`` run-time function for detecting whether
+  the library has NVIDIA CUDA-aware support.
+
+* :doc:`rocm </tuning-apps/accelerators/rocm>`: Provides the
+  ``MPIX_ROCM_AWARE_SUPPORT`` compile-time macro and the
+  ``MPIX_Query_rocm_support()`` run-time function for detecting whether
+  the library has AMD ROCm-aware support.
+
+* :doc:`ftmpi </features/ulfm>`: An implementation of the MPI Forum's
+  User-Level Failure Mitigation (ULFM) proposal, providing the
+  ``MPIX_Comm_*`` functions and ``MPIX_ERR_*`` error codes for writing
+  fault-tolerant MPI applications.
+
+* :doc:`shortfloat </features/extension-shortfloat>`: Provides MPI
+  datatypes corresponding to short / half-precision floating point C
+  and C++ language types, when such types are available.
+
+* :doc:`example </features/extension-example>`: A non-functional
+  extension whose only purpose is to demonstrate how to create a new
+  Open MPI extension.
+
+.. toctree::
+   :hidden:
+
+   extension-affinity
+   extension-shortfloat
+   extension-example
 
 Compiling the extensions
 ------------------------
 
-Open MPI extensions are all enabled by default; they can be disabled
-via the ``--disable-mpi-ext`` command line switch.
+Most Open MPI extensions are enabled by default; the exceptions are
+extensions that require functionality not present in your build
+environment (for example, ``shortfloat`` is only built when the
+compiler provides a suitable short / half-precision floating point
+type) and the developer-only ``example`` extension (which is only
+built when explicitly requested).
+
+The set of extensions to build is selected at configure time:
+
+* ``--enable-mpi-ext`` (the default) builds all available extensions.
+* ``--enable-mpi-ext=LIST`` builds only the comma-separated extensions
+  named in ``LIST`` |mdash| for example,
+  ``--enable-mpi-ext=cuda,rocm``.
+* ``--disable-mpi-ext`` builds none of the extensions.
+
+Each extension's own page (linked above) documents any additional
+build-time prerequisites and the configure options needed to satisfy
+them.
 
-Since extensions are meant to be used by advanced users only, this
-file does not document which extensions are available or what they do.
-Look in the ``ompi/mpiext`` directory in a distribution Open MPI
-tarball to see the extensions; each subdirectory of that directory
-contains an extension.  Each has a ``README`` file that describes what
-it does.
+You can confirm which extensions were compiled into a given Open MPI
+installation with ``ompi_info``:
+
+.. code-block:: sh
+
+   shell$ ompi_info | grep "MPI extensions"
+          MPI extensions: affinity, cuda, ftmpi, rocm
 
 Using the extensions
 --------------------
@@ -75,7 +112,7 @@ prototypes, constant declarations, etc.  For example:
        char exists[OMPI_AFFINITY_STRING_MAX];
 
        OMPI_Affinity_str(OMPI_AFFINITY_LAYOUT_FMT, ompi_bound,
-                         current_bindings, exists);
+                         current_binding, exists);
    #endif
 
        MPI_Finalize();
@@ -85,6 +122,15 @@ prototypes, constant declarations, etc.  For example:
 Notice that the Open MPI-specific code is surrounded by the ``#if``
 statement to ensure that it is only ever compiled by Open MPI.
 
+Including ``<mpi-ext.h>`` defines the preprocessor macro
+``OMPI_HAVE_MPI_EXT`` to ``1``.  In addition, for each extension that
+is present, it defines a macro named ``OMPI_HAVE_MPI_EXT_<NAME>`` (with
+``<NAME>`` being the uppercased extension name, e.g.,
+``OMPI_HAVE_MPI_EXT_AFFINITY``) to ``1``.  Applications can test these
+macros to portably guard their use of a given extension |mdash| both
+against Open MPI builds that omitted the extension and against other
+MPI implementations that do not provide ``<mpi-ext.h>`` at all.
+
 The Open MPI wrapper compilers (``mpicc`` and friends) should
 automatically insert all relevant compiler and linker flags necessary
 to use the extensions.  No special flags or steps should be necessary
diff --git a/docs/features/index.rst b/docs/features/index.rst
index 3afb117dabb..0662a60cf20 100644
--- a/docs/features/index.rst
+++ b/docs/features/index.rst
@@ -14,4 +14,3 @@ categories of Open MPI-specific features.
    profiling
    extensions
    ulfm
-   java
diff --git a/docs/features/java.rst b/docs/features/java.rst
deleted file mode 100644
index 81fedd72bb7..00000000000
--- a/docs/features/java.rst
+++ /dev/null
@@ -1,350 +0,0 @@
-.. _open-mpi-java-label:
-
-Open MPI Java bindings
-======================
-
-Open MPI |ompi_ver| provides support for Java-based MPI applications.
-
-.. warning:: The Open MPI Java bindings are provided on a
-   "provisional" basis |mdash| i.e., they are not part of the current or
-   proposed MPI standards.  Thus, inclusion of Java support is not
-   required by the standard.  Continued inclusion of the Java bindings
-   is contingent upon active user interest and continued developer
-   support.
-
-The rest of this document provides step-by-step instructions on
-building OMPI with Java bindings, and compiling and running Java-based
-MPI applications. Also, part of the functionality is explained with
-examples. Further details about the design, implementation and usage
-of Java bindings in Open MPI can be found in its canonical reference
-paper [#ompijava]_. The bindings follow a JNI approach, that is, we do
-not provide a pure Java implementation of MPI primitives, but a thin
-layer on top of the C implementation. This is the same approach as in
-mpiJava [#mpijava]_; in fact, mpiJava was taken as a starting point
-for Open MPI Java bindings, but they were later totally rewritten.
-
-Building the Java bindings
---------------------------
-
-Java support requires that Open MPI be built at least with shared
-libraries (i.e., ``--enable-shared``).  Note that this is the default
-for Open MPI, so you don't have to explicitly add the option. The Java
-bindings will build only if ``--enable-mpi-java`` is specified, and a
-JDK is found in a typical system default location.
-
-If the JDK is not in a place where we automatically find it, you can
-specify the location. For example, this is required on the Mac
-platform as the JDK headers are located in a non-typical location. Two
-options are available for this purpose:
-
-#. ``--with-jdk-bindir=<foo>``: the location of ``javac`` and ``javah``
-#. ``--with-jdk-headers=<bar>``: the directory containing ``jni.h``
-
-Some example configurations are provided in Open MPI configuration
-platform files under ``contrib/platform/hadoop``. These examples can
-provide a starting point for your own custom configuration.
-
-In summary, therefore, you can configure the system using the
-following Java-related options::
-
-  $ ./configure --with-platform=contrib/platform/hadoop/<your-platform> ...
-
-or::
-
-  $ ./configure --enable-mpi-java --with-jdk-bindir=<foo> --with-jdk-headers=<bar> ...
-
-or simply::
-
-  $ ./configure --enable-mpi-java ...
-
-if JDK is in a "standard" place that ``configure`` can automatically
-find.
-
-Building Java MPI applications
-------------------------------
-
-The ``mpijavac`` wrapper compiler is available for compiling
-Java-based MPI applications. It ensures that all required Open MPI
-libraries and classpaths are defined.  For example:
-
-.. code-block::
-
-   $ mpijavac Hello.java
-
-You can use the ``--showme`` option to see the full command line of
-the Java compiler that is invoked:
-
-.. code-block::
-
-   $ mpijavac Hello.java --showme
-   /usr/bin/javac -cp /opt/openmpi/lib/mpi.jar Hello.java
-
-Note that if you are specifying a ``-cp`` argument on the command line
-to pass your application-specific classpaths, Open MPI will *extend*
-that argument to include the ``mpi.jar``:
-
-.. code-block::
-
-   $ mpijavac -cp /path/to/my/app.jar Hello.java --showme
-   /usr/bin/javac -cp /path/to/my/app.jar:/opt/openmpi/lib/mpi.jar Hello.java
-
-Similarly, if you have a ``CLASSPATH`` environment variable defined,
-``mpijavac`` will convert that into a ``-cp`` argument and extend it
-to include the ``mpi.jar``:
-
-.. code-block::
-
-   $ export CLASSPATH=/path/to/my/app.jar
-   $ mpijavac Hello.java --showme
-   /usr/bin/javac -cp /path/to/my/app.jar:/opt/openmpi/lib/mpi.jar Hello.java
-
-
-Running Java MPI applications
------------------------------
-
-Once your application has been compiled, you can run it with the
-standard ``mpirun`` command line::
-
-  $ mpirun <options> java <your-java-options> <my-app>
-
-``mpirun`` will detect the ``java`` token and ensure that the required
-MPI libraries and class paths are defined to support execution. You
-therefore do **not** need to specify the Java library path to the MPI
-installation, nor the MPI classpath. Any classpath definitions
-required for your application should be specified either on the
-command line or via the ``CLASSPATH`` environment variable. Note that
-the local directory will be added to the classpath if nothing is
-specified.
-
-.. note:: The ``java`` executable, all required libraries, and your
-          application classes must be available on all nodes.
-
-Basic usage of the Java bindings
---------------------------------
-
-There is an MPI package that contains all classes of the MPI Java
-bindings: ``Comm``, ``Datatype``, ``Request``, etc. These classes have a
-direct correspondence with handle types defined by the MPI standard. MPI
-primitives are just methods included in these classes. The convention
-used for naming Java methods and classes is the usual camel-case
-convention, e.g., the equivalent of ``MPI_File_set_info(fh,info)`` is
-``fh.setInfo(info)``, where ``fh`` is an object of the class ``File``.
-
-Apart from classes, the MPI package contains predefined public
-attributes under a convenience class ``MPI``. Examples are the
-predefined communicator ``MPI.COMM_WORLD`` and predefined datatypes such
-as ``MPI.DOUBLE``. Also, MPI initialization and finalization are methods
-of the ``MPI`` class and must be invoked by all MPI Java
-applications. The following example illustrates these concepts:
-
-.. code-block:: java
-
-   import mpi.*;
-
-   class ComputePi {
-
-      public static void main(String args[]) throws MPIException {
-
-          MPI.Init(args);
-
-          int rank = MPI.COMM_WORLD.getRank(),
-              size = MPI.COMM_WORLD.getSize(),
-              nint = 100; // Intervals.
-          double h = 1.0/(double)nint, sum = 0.0;
-
-          for (int i=rank+1; i<=nint; i+=size) {
-              double x = h * ((double)i - 0.5);
-              sum += (4.0 / (1.0 + x * x));
-          }
-
-          double sBuf[] = { h * sum },
-                 rBuf[] = new double[1];
-
-          MPI.COMM_WORLD.reduce(sBuf, rBuf, 1, MPI.DOUBLE, MPI.SUM, 0);
-
-          if (rank == 0) {
-              System.out.println("PI: " + rBuf[0]);
-          }
-          MPI.Finalize();
-      }
-   }
-
-Exception handling
-------------------
-
-The Java bindings in Open MPI support exception handling. By default,
-errors are fatal, but this behavior can be changed. The Java API will
-throw exceptions if the ``MPI.ERRORS_RETURN`` error handler is set:
-
-.. code-block:: java
-
-   MPI.COMM_WORLD.setErrhandler(MPI.ERRORS_RETURN);
-
-If you add this statement to your program, it will show the line
-where it breaks, instead of just crashing in case of an error.
-Error-handling code can be separated from main application code by
-means of try-catch blocks, for instance:
-
-.. code-block:: java
-
-   try
-   {
-       File file = new File(MPI.COMM_SELF, "filename", MPI.MODE_RDONLY);
-   }
-   catch(MPIException ex)
-   {
-       System.err.println("Error Message: "+ ex.getMessage());
-       System.err.println("  Error Class: "+ ex.getErrorClass());
-       ex.printStackTrace();
-       System.exit(-1);
-   }
-
-How to specify buffers
-----------------------
-
-In MPI primitives that require a buffer (either send or receive), the
-Java API admits a Java array. Since Java arrays can be relocated by
-the Java runtime environment, the MPI Java bindings need to make a
-copy of the contents of the array to a temporary buffer, then pass the
-pointer to this buffer to the underlying C implementation. From the
-practical point of view, this implies an overhead associated to all
-buffers that are represented by Java arrays. The overhead is small for
-small buffers but increases for large arrays.
-
-There is a pool of temporary buffers with a default capacity of 64K.
-If a temporary buffer of 64K or less is needed, then the buffer will
-be obtained from the pool. But if the buffer is larger, then it will
-be necessary to allocate the buffer and free it later.
-
-The default capacity of pool buffers can be modified with an Open MPI
-MCA parameter::
-
-  $ mpirun --mca ompi_mpi_java_eager SIZE ...
-
-The value of ``SIZE`` can be:
-
-* ``N``: An integer number of bytes
-* ``Nk``: An integer number (suffixed with ``k``) of kilobytes
-* ``Nm``: An integer number (suffixed with ``m``) of megabytes
-
-An alternative is to use "direct buffers" provided by standard classes
-available in the Java SDK such as ``ByteBuffer``. For convenience,
-Open MPI provides a few static methods ``new[Type]Buffer`` in the
-``MPI`` class to create direct buffers for a number of basic
-datatypes. Elements of the direct buffer can be accessed with methods
-``put()`` and ``get()``, and the number of elements in the buffer can
-be obtained with the method ``capacity()``. This example illustrates
-its use:
-
-.. code-block:: java
-
-   int myself = MPI.COMM_WORLD.getRank();
-   int tasks  = MPI.COMM_WORLD.getSize();
-
-   IntBuffer in  = MPI.newIntBuffer(MAXLEN * tasks),
-             out = MPI.newIntBuffer(MAXLEN);
-
-   for (int i = 0; i < MAXLEN; i++)
-       out.put(i, myself);      // fill the buffer with the rank
-
-   Request request = MPI.COMM_WORLD.iAllGather(
-                     out, MAXLEN, MPI.INT, in, MAXLEN, MPI.INT);
-   request.waitFor();
-   request.free();
-
-   for (int i = 0; i < tasks; i++) {
-       for (int k = 0; k < MAXLEN; k++) {
-           if (in.get(k + i * MAXLEN) != i)
-               throw new AssertionError("Unexpected value");
-       }
-   }
-
-Direct buffers are available for: ``BYTE``, ``CHAR``, ``SHORT``,
-``INT``, ``LONG``, ``FLOAT``, and ``DOUBLE``.
-
-.. note:: There is no direct buffer for booleans.
-
-Direct buffers are not a replacement for arrays, because they have
-higher allocation and deallocation costs than arrays. In some cases
-arrays will be a better choice. You can easily convert a buffer into
-an array and vice versa.
-
-.. important:: All non-blocking methods *must* use direct buffers.
-               Only blocking methods can choose between arrays and
-               direct buffers.
-
-The above example also illustrates that it is necessary to call the
-``free()`` method on objects whose class implements the ``Freeable``
-interface. Otherwise, a memory leak will occur.
-
-Specifying offsets in buffers
------------------------------
-
-In a C program, it is common to specify an offset in a array with
-``&array[i]`` or ``array+i`` to send data starting from a given
-position in the array. The equivalent form in the Java bindings is to
-``slice()`` the buffer to start at an offset. Making a ``slice()`` on
-a buffer is only necessary, when the offset is not zero. Slices work
-for both arrays and direct buffers.
-
-.. code-block:: java
-
-   import static mpi.MPI.slice;
-   // ...
-   int numbers[] = new int[SIZE];
-   // ...
-   MPI.COMM_WORLD.send(slice(numbers, offset), count, MPI.INT, 1, 0);
-
-
-Supported APIs
---------------
-
-Complete MPI-3.1 coverage is provided in the Open MPI Java bindings,
-with a few exceptions:
-
-* The bindings for the ``MPI_Neighbor_alltoallw`` and
-  ``MPI_Ineighbor_alltoallw`` functions are not implemented.
-
-* Also excluded are functions that incorporate the concepts of
-  explicit virtual memory addressing, such as
-  ``MPI_Win_shared_query``.
-
-
-Known issues
-------------
-
-There exist issues with the Omnipath (PSM2) interconnect involving
-Java. The problems definitely exist in PSM2 v10.2; we have not tested
-previous versions.
-
-As of November 2016, there is not yet a PSM2 release that completely
-fixes the issue.
-
-The following ``mpirun`` command options will disable PSM2::
-
-   shell$ mpirun ... --mca mtl ^psm2 java ...your-java-options... your-app-class
-
-
-Questions?  Problems?
----------------------
-
-The Java API documentation is generated at build time in
-``$prefix/share/doc/openmpi/javadoc``.
-
-Additionally, `this Cisco blog post
-<https://blogs.cisco.com/performance/java-bindings-for-open-mpi>`_ has
-quite a bit of information about the Open MPI Java bindings.
-
-If you have any problems, or find any bugs, please feel free to report
-them to `Open MPI user's mailing list
-<https://www.open-mpi.org/community/lists/ompi.php>`_.
-
-.. rubric:: Footnotes
-
-.. [#ompijava] O. Vega-Gisbert, J. E. Roman, and J. M. Squyres. "Design
-   and implementation of Java bindings in Open MPI". Parallel Comput.
-   59: 1-20 (2016).
-
-.. [#mpijava] M. Baker et al. "mpiJava: An object-oriented Java
-   interface to MPI". In Parallel and Distributed Processing, LNCS
-   vol. 1586, pp. 748-762, Springer (1999).
diff --git a/docs/features/profiling.rst b/docs/features/profiling.rst
index e0de0597cad..8b6001d11cf 100644
--- a/docs/features/profiling.rst
+++ b/docs/features/profiling.rst
@@ -1,11 +1,10 @@
-.. _open-mpi-profileing-label:
+.. _open-mpi-profiling-label:
 
 Open MPI profiling interface
 ============================
 
-Open MPI |ompi_ver| supportings the "PMPI" profiling interface as
-perscribed by the MPI standard for the C and Fortran bindings (*not*
-the :ref:`Open MPI Java binding extensions <open-mpi-java-label>`).
+Open MPI |ompi_ver| supports the "PMPI" profiling interface as
+prescribed by the MPI standard for the C and Fortran bindings.
 
 Per MPI-4.0 section 15.2.1, MPI implementations must document which
 bindings layer on top of each other, so that profile developers know
@@ -15,7 +14,7 @@ level routines.
 
 In general, Open MPI's Fortran bindings are implemented on top of the
 C bindings.  Hence, a profile developer who implements ``MPI_Init()``
-in C will also intecept all Fortran calls to ``MPI_INIT`` regardless
+in C will also intercept all Fortran calls to ``MPI_INIT`` regardless
 of whether the user is utilizing the ``mpif.h``, ``use mpi``, or ``use
 mpi_f08`` Fortran interfaces.
 
@@ -78,4 +77,4 @@ interfaces.  Indeed, that is the most portable way to implement a
 profiling interface.  Since Open MPI's Fortran bindings are |mdash|
 for the most part |mdash| implemented on top of its C bindings,
 profile developers can ignore all Fortran interfaces except for the
-ones enumated above.
+ones enumerated above.
diff --git a/docs/features/ulfm.rst b/docs/features/ulfm.rst
index 0ec3570c927..cbf8c1201a5 100644
--- a/docs/features/ulfm.rst
+++ b/docs/features/ulfm.rst
@@ -190,7 +190,7 @@ mpi_ft_foo <value>`` for Open MPI options, and with ``--prtemca
 errmgr_detector_bar <value>`` for PRTE options.
 
 .. important:: The main control for enabling/disabling fault tolerance
-   at runtime is the ``--with-ft ulfm`` (or its synomym ``--with-ft mpi``)
+   at runtime is the ``--with-ft ulfm`` (or its synonym ``--with-ft mpi``)
    ``mpirun`` CLI option. This option sets up multiple subsystems in
    Open MPI to enable fault tolerance. The options described below are
    best used to override the default behavior after the ``--with-ft ulfm``
@@ -305,7 +305,7 @@ three classifications:
    after a failure.
 3. **Disabled:** This framework/component will cause unspecified behavior when
    fault tolerance is enabled. As a consequence, it will be disabled when the
-   ``--with-ft ulfm`` option is used (see above for defails about implicit
+   ``--with-ft ulfm`` option is used (see above for details about implicit
    parameters loaded from the ``ft-mpi`` aggregate param file).
 
 Any framework or component not listed below are categorized as **Unmodified**,
@@ -371,7 +371,7 @@ ULFM Integrated in Open MPI
 
 As of |ompi_ver|, ULFM is now integrated directly in to the community
 release of Open MPI.  The following sections describe previous ULFM
-standlone releases.
+standalone releases.
 
 ULFM Standalone Release 4.0.2u1
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -434,7 +434,7 @@ main (November 2018).
 * Bugfixes:
 
   * Correct the behavior of process placement during an MPI_COMM_SPAWN
-    when some slots were occcupied by failed processes.
+    when some slots were occupied by failed processes.
   * MPI_COMM_SPAWN accepts process placement directives in the Info object.
   * Fixed deadlocks in some NBC collective operations.
   * Crashes and deadlocks in MPI_FINALIZE have been resolved.
diff --git a/docs/generate-code-of-conduct-rst.py b/docs/generate-code-of-conduct-rst.py
new file mode 100755
index 00000000000..a0f12316664
--- /dev/null
+++ b/docs/generate-code-of-conduct-rst.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+#
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+"""Convert Open MPI's Markdown CODE_OF_CONDUCT.md to reStructuredText."""
+
+import argparse
+import re
+from pathlib import Path
+
+HEADING_RE = re.compile(r"^(#{1,6})\s+(.+?)\s*#*\s*$")
+REF_DEF_RE = re.compile(r"^\[([^\]]+)\]:\s*(\S+)\s*$")
+REF_LINK_RE = re.compile(r"\[([^\]]+)\]\[([^\]]+)\]")
+INLINE_LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
+BULLET_RE = re.compile(r"^\s*[*+-]\s+")
+UNDERLINES = ["=", "-", "~", "^", '"', "'"]
+
+
+def _rst_link(text, url):
+    return "`{} <{}>`_".format(text, url)
+
+
+def _convert_links(line, refs):
+    def repl_ref(match):
+        text = match.group(1)
+        ref = match.group(2)
+        return _rst_link(text, refs.get(ref, ref))
+
+    def repl_inline(match):
+        return _rst_link(match.group(1), match.group(2))
+
+    line = REF_LINK_RE.sub(repl_ref, line)
+    line = INLINE_LINK_RE.sub(repl_inline, line)
+    return line
+
+
+def convert(lines):
+    refs = {}
+    for line in lines:
+        match = REF_DEF_RE.match(line.strip())
+        if match:
+            refs[match.group(1)] = match.group(2)
+
+    out = [
+        "..",
+        "   This file was generated from CODE_OF_CONDUCT.md by docs/Makefile.am.",
+        "   Do not edit directly.",
+        "",
+    ]
+
+    skip_next_blank = False
+    prev_bullet = False
+    for line in lines:
+        if REF_DEF_RE.match(line.strip()):
+            continue
+        if skip_next_blank and not line.strip():
+            skip_next_blank = False
+            continue
+        skip_next_blank = False
+
+        match = HEADING_RE.match(line)
+        if match:
+            if out and out[-1] != "":
+                out.append("")
+            title = _convert_links(match.group(2), refs)
+            level = min(len(match.group(1)) - 1, len(UNDERLINES) - 1)
+            out.extend([title, UNDERLINES[level] * len(title), ""])
+            skip_next_blank = True
+            prev_bullet = False
+        else:
+            is_bullet = bool(BULLET_RE.match(line))
+            if is_bullet and out and out[-1] != "" and not prev_bullet:
+                out.append("")
+            out.append(_convert_links(line, refs))
+            prev_bullet = is_bullet
+
+    while out and out[-1] == "":
+        out.pop()
+    return "\n".join(out) + "\n"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--output", required=True)
+    args = parser.parse_args()
+
+    input_path = Path(args.input)
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(
+        convert(input_path.read_text(encoding="utf-8").splitlines()),
+        encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/generate-llm-docs.py b/docs/generate-llm-docs.py
new file mode 100755
index 00000000000..d79a3ea7805
--- /dev/null
+++ b/docs/generate-llm-docs.py
@@ -0,0 +1,1431 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2026 Jeffrey M. Squyres.  All rights reserved.
+#
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+"""Generate LLM-friendly documentation artifacts for the Open MPI MPI APIs.
+
+This produces, under a build-tree staging directory, the artifact tree that a
+copy step in docs/Makefile.am publishes into the Sphinx HTML output after the
+Sphinx run (not via ``html_extra_path``, since the staged Markdown must be
+excluded from Sphinx source discovery and ``exclude_patterns`` would also
+suppress an ``html_extra_path`` entry; see specs/llms-friendly-docs/spec.md):
+
+  <staging>/
+    llms.txt
+    llms/
+      openmpi-mpi-api.jsonl
+      openmpi-mpi-api.md
+      openmpi-mpi-api-c.md
+      openmpi-mpi-api-fortran-mpifh.md
+      openmpi-mpi-api-fortran-use-mpi.md
+      openmpi-mpi-api-fortran-use-mpi-f08.md
+      openmpi-mpi-interface-guide.md      (curated; copied from llms-src)
+      openmpi-mpi-examples.md             (curated; copied from llms-src)
+      openmpi-mpi-api.schema.json         (curated; copied from llms-src)
+      openmpi-docs-manifest.schema.json   (curated; copied from llms-src)
+      openmpi-docs-manifest.json
+      man-openmpi/man3/MPI_<name>.3.md
+      man-openmpi/man1/<command>.1.md      (command corpus; no JSONL records)
+
+Build identity (git commit/describe, generation timestamp) lives only in the
+manifest; every other artifact is wall-clock-free and deterministic at a given
+commit.  Shared metadata logic comes from ompi_docs_common.py.
+
+Targets the Python 3.6 floor (see python_min_version in VERSION).
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import posixpath
+import re
+
+import ompi_docs_common as common
+
+SCHEMA_VERSION = 1
+ARTIFACT_SCHEMA_VERSION = 1
+
+
+class LinkMaker:
+    """Builds the URLs that the generated artifacts use to link to each other
+    and to the human-facing HTML documentation.
+
+    There are two consumers, and they want different link styles:
+
+    * A **Read the Docs** build publishes to ``docs.open-mpi.org/en/<slug>/``.
+      Links must be absolute and use that version slug, so a reader of the
+      published site (or a record copied out of it) can resolve them.  Pass the
+      absolute base (e.g. ``https://docs.open-mpi.org/en/main``) and every link
+      becomes ``<base>/<target>``.
+
+    * A **local build from git** produces the artifacts for a *local* LLM/tool
+      that reads the files straight off disk.  There is no docs.open-mpi.org
+      site in play, so the RTD URL scheme is irrelevant; what matters is that
+      the tree is self-contained and portable.  Pass ``None`` and every link
+      becomes relative to the file that contains it, so the local tree resolves
+      no matter where it lives.
+
+    Always feed :meth:`link` *logical* paths relative to the documentation
+    version root (e.g. ``"llms/openmpi-mpi-api.jsonl"``,
+    ``"man-openmpi/man3/MPI_Init.3.html"``) -- never real on-disk paths.  This
+    keeps output independent of the output directory, which the determinism
+    check relies on (it generates into two different directories and diffs).
+    """
+
+    def __init__(self, url_base):
+        # Absolute base (no trailing slash) for an RTD/explicit build, or None
+        # for a local build (relative links).
+        self._base = url_base.rstrip('/') if url_base else None
+
+    @property
+    def absolute(self):
+        return self._base is not None
+
+    def link(self, target, source):
+        """URL to ``target`` from the file ``source`` (both root-relative)."""
+        if self._base is not None:
+            return "{}/{}".format(self._base, target)
+        return posixpath.relpath(target, posixpath.dirname(source) or '.')
+
+LANG_C = "c"
+LANG_MPIFH = "fortran_mpifh"
+LANG_USE_MPI = "fortran_use_mpi"
+LANG_F08 = "fortran_mpi_f08"
+
+# Curated source files (committed under docs/llms-src/) copied verbatim into
+# the published llms/ tree.
+CURATED_FILES = [
+    "openmpi-mpi-interface-guide.md",
+    "openmpi-mpi-examples.md",
+    "openmpi-runtime-introspection.md",
+    "openmpi-mpi-api.schema.json",
+    "openmpi-docs-manifest.schema.json",
+]
+
+MEDIA_TYPES = {
+    ".md": "text/markdown",
+    ".jsonl": "application/jsonl",
+    ".json": "application/json",
+    ".txt": "text/plain",
+}
+
+# Heuristic API-family categorization by name prefix.  Matching is by list
+# order (the first matching prefix wins), so list more-specific prefixes
+# before less-specific ones.
+CATEGORY_PREFIXES = [
+    ("MPI_T_", "tools"),
+    ("MPI_File_", "io"),
+    ("MPI_Win_", "rma"),
+    ("MPI_Comm_", "communicator"),
+    ("MPI_Group_", "group"),
+    ("MPI_Type_", "datatype"),
+    ("MPI_Session_", "sessions"),
+    ("MPI_Info_", "info"),
+    ("MPI_Cart_", "topology"),
+    ("MPI_Graph_", "topology"),
+    ("MPI_Dist_graph_", "topology"),
+    ("MPI_Errhandler_", "error-handling"),
+    ("MPI_Add_error", "error-handling"),
+    ("MPI_Error", "error-handling"),
+]
+_COLLECTIVE_BASE = set("""
+    MPI_Barrier MPI_Bcast MPI_Gather MPI_Gatherv MPI_Scatter MPI_Scatterv
+    MPI_Allgather MPI_Allgatherv MPI_Alltoall MPI_Alltoallv MPI_Alltoallw
+    MPI_Reduce MPI_Allreduce MPI_Reduce_scatter MPI_Reduce_scatter_block
+    MPI_Scan MPI_Exscan
+    MPI_Neighbor_allgather MPI_Neighbor_allgatherv MPI_Neighbor_alltoall
+    MPI_Neighbor_alltoallv MPI_Neighbor_alltoallw
+""".split())
+
+
+def _expand_collectives(bases):
+    """Expand blocking collective names to their nonblocking (MPI_I...) and
+    persistent (..._init) variants. Over-generation is harmless: names that do
+    not correspond to a real procedure simply never match."""
+    out = set()
+    for n in bases:
+        out.add(n)
+        out.add("MPI_I" + n[4].lower() + n[5:])
+        out.add(n + "_init")
+    return out
+
+
+COLLECTIVE_NAMES = _expand_collectives(_COLLECTIVE_BASE)
+POINT_TO_POINT_NAMES = set("""
+    MPI_Send MPI_Recv MPI_Sendrecv MPI_Sendrecv_replace MPI_Bsend MPI_Ssend
+    MPI_Rsend MPI_Isend MPI_Irecv MPI_Ibsend MPI_Issend MPI_Irsend
+    MPI_Probe MPI_Iprobe MPI_Mprobe MPI_Improbe MPI_Mrecv MPI_Imrecv
+    MPI_Wait MPI_Waitall MPI_Waitany MPI_Waitsome MPI_Test MPI_Testall
+    MPI_Testany MPI_Testsome MPI_Get_count MPI_Cancel MPI_Start MPI_Startall
+    MPI_Send_init MPI_Bsend_init MPI_Ssend_init MPI_Rsend_init MPI_Recv_init
+    MPI_Isendrecv MPI_Isendrecv_replace
+""".split())
+# Process-management / environment procedures.
+PROCESS_NAMES = set("""
+    MPI_Init MPI_Init_thread MPI_Finalize MPI_Initialized MPI_Finalized
+    MPI_Query_thread MPI_Is_thread_main MPI_Abort MPI_Get_processor_name
+    MPI_Get_version MPI_Get_library_version MPI_Wtime MPI_Wtick MPI_Pcontrol
+    MPI_Get_hw_resource_info
+""".split())
+# One-sided (RMA) communication procedures whose names do not start with
+# MPI_Win_ (window-management names are matched by the MPI_Win_ prefix).
+RMA_NAMES = set("""
+    MPI_Get MPI_Put MPI_Accumulate MPI_Get_accumulate MPI_Fetch_and_op
+    MPI_Compare_and_swap MPI_Rget MPI_Rput MPI_Raccumulate MPI_Rget_accumulate
+""".split())
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def setup_cli():
+    parser = argparse.ArgumentParser(
+        description="Generate LLM-friendly docs for the Open MPI MPI APIs")
+    parser.add_argument('--srcdir', required=True, help='docs source dir')
+    parser.add_argument('--builddir', required=True, help='docs build dir')
+    parser.add_argument('--outdir', default=None,
+                        help='staging output dir (default: <builddir>/llms-build)')
+    parser.add_argument('--url-base', default=None,
+                        help='absolute public docs URL base (e.g. '
+                             'https://docs.open-mpi.org/en/main); forces '
+                             'absolute links. Default: absolute from the Read '
+                             'the Docs environment if present, otherwise '
+                             'relative links for a local build')
+    return parser.parse_args()
+
+
+# ---------------------------------------------------------------------------
+# RST -> Markdown conversion (closed vocabulary; see spec)
+# ---------------------------------------------------------------------------
+
+HEADING_LEVELS = {'=': 1, '-': 2, '^': 3, '~': 4, '"': 5, '+': 6, '#': 1, '*': 2}
+UNDERLINE_RE = re.compile(r'^([=\-^~"+#*])\1{2,}\s*$')
+DIRECTIVE_RE = re.compile(r'^(\s*)\.\.\s+([a-zA-Z0-9_-]+)::\s*(.*)$')
+COMMENT_RE = re.compile(r'^(\s*)\.\.\s+(.*)$')
+INCLUDE_RE = re.compile(r'^\s*\.\.\s+include::\s*(\S+)\s*$')
+OPTION_RE = re.compile(r'^\s+:[a-zA-Z-]+:.*$')
+
+# Substitutions used in the man pages (whitelist; values filled from VERSION).
+STATIC_SUBS = {
+    'mdash': '—',
+    'rarrow': '→',
+    'deprecated_favor': 'this routine is deprecated in favor of',
+}
+
+
+def build_substitutions(version_info):
+    subs = dict(STATIC_SUBS)
+    if 'mpi_standard_version' in version_info:
+        subs['mpi_standard_version'] = version_info['mpi_standard_version']
+        subs['mpi_standard_major_version'] = version_info['mpi_standard_major_version']
+        subs['mpi_standard_minor_version'] = version_info['mpi_standard_minor_version']
+    subs['ompi_ver'] = version_info['ompi_version']
+    subs['ompi_series'] = version_info['ompi_series']
+    return subs
+
+
+def resolve_include_path(target, including_file, srcdir, builddir):
+    """Resolve an ``.. include::`` target to an existing file path or None."""
+    base = os.path.dirname(including_file)
+    cand = os.path.normpath(os.path.join(base, target))
+    candidates = [cand]
+    # Generated bindings live in the build tree; map srcdir->builddir.
+    srcdir = os.path.abspath(srcdir)
+    builddir = os.path.abspath(builddir)
+    ac = os.path.abspath(cand)
+    if ac.startswith(srcdir):
+        candidates.append(os.path.join(builddir, os.path.relpath(ac, srcdir)))
+    if ac.startswith(builddir):
+        candidates.append(os.path.join(srcdir, os.path.relpath(ac, builddir)))
+    for c in candidates:
+        if os.path.isfile(c):
+            return c
+    return None
+
+
+def expand_includes(text, including_file, srcdir, builddir, _seen=None):
+    """Recursively inline ``.. include::`` directives, honoring :start-after:."""
+    if _seen is None:
+        _seen = set()
+    out = []
+    lines = text.split('\n')
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        m = INCLUDE_RE.match(line)
+        if not m:
+            out.append(line)
+            i += 1
+            continue
+
+        target = m.group(1)
+        # Collect option lines (e.g., :start-after:) that follow the include.
+        start_after = None
+        i += 1
+        while i < len(lines) and OPTION_RE.match(lines[i]):
+            opt = lines[i].strip()
+            mo = re.match(r':start-after:\s*(.*)$', opt)
+            if mo:
+                start_after = mo.group(1).strip()
+            i += 1
+
+        path = resolve_include_path(target, including_file, srcdir, builddir)
+        if path is None or path in _seen:
+            # Unresolvable or cyclic include: drop it (do not leak the directive).
+            continue
+        with open(path, encoding='utf-8') as fp:
+            inc = fp.read()
+        if start_after is not None:
+            idx = inc.find(start_after)
+            if idx >= 0:
+                inc = inc[idx + len(start_after):]
+        nested = expand_includes(inc, path, srcdir, builddir,
+                                 _seen | {path})
+        out.append(nested)
+    return '\n'.join(out)
+
+
+def make_ref_resolver(known_pages, linkmaker, source):
+    """Return a function that turns :ref: roles into Markdown links/text.
+
+    ``source`` is the root-relative path of the file whose body is being
+    rendered (e.g. ``"llms/man-openmpi/man3/x"``), so that in a local
+    (relative-link) build the man-page links resolve correctly from it.
+    """
+    # O(1) case-insensitive lookup: labels are often lowercase (e.g. mpi_send).
+    lower_map = {p.lower(): p for p in known_pages}
+
+    def html_url(name):
+        return linkmaker.link("man-openmpi/man3/{}.3.html".format(name), source)
+
+    ref_re = re.compile(r':ref:`([^`<]+?)(?:\s*<([^`>]+)>)?`')
+
+    def repl(m):
+        text = m.group(1).strip()
+        target = (m.group(2) or text).strip()
+        # Normalize a target like "MPI_Send(3)" or label "mpi_send".
+        cand = target.replace('(3)', '').strip()
+        page = cand if cand in known_pages else lower_map.get(cand.lower())
+        if page is not None:
+            return "[{}]({})".format(text, html_url(page))
+        return text
+
+    def resolve(text):
+        return ref_re.sub(repl, text)
+
+    return resolve
+
+
+HYPERLINK_RE = re.compile(r'`([^`<]+?)\s*<([^`>]+)>`_+')
+# :doc:`Title </path>` or :doc:`/path` -- the target doc is human-facing RST,
+# not part of the LLM corpus, so reduce the role to its display text.
+DOC_RE = re.compile(r':doc:`([^`<]+?)(?:\s*<[^`>]+>)?`')
+
+
+def resolve_inline(text, subs, ref_resolve):
+    # :ref: roles first (may span wrapped lines).
+    text = ref_resolve(text)
+    # :doc: roles -> display text (the target is not in the LLM corpus).
+    text = DOC_RE.sub(lambda m: m.group(1).strip(), text)
+    # RST external hyperlink: `text <url>`_ (or `__`) -> [text](url).
+    text = HYPERLINK_RE.sub(
+        lambda m: '[{}]({})'.format(m.group(1).strip(), m.group(2).strip()), text)
+    # Substitutions (whitelist only -> literal text like MPI_{Wait|Test} is safe).
+    def sub_repl(m):
+        name = m.group(1)
+        return subs.get(name, m.group(0))
+    text = re.sub(r'\|([a-zA-Z_]+)\|', sub_repl, text)
+    # RST inline literal ``x`` -> Markdown `x` (collapse double backticks).
+    text = text.replace('``', '`')
+    return text
+
+
+def _dedent(block_lines):
+    indents = [len(l) - len(l.lstrip(' ')) for l in block_lines if l.strip()]
+    n = min(indents) if indents else 0
+    return [l[n:] if len(l) >= n else l for l in block_lines]
+
+
+def rst_to_markdown(text, subs, ref_resolve):
+    """Convert the (already include-expanded) RST text to Markdown.
+
+    Prose lines are buffered and resolved as a paragraph so that inline
+    constructs that wrap across source lines (multi-line :ref: roles, RST
+    hyperlinks) are handled correctly. Code-block bodies are emitted verbatim
+    and never passed through inline resolution.
+    """
+    lines = text.split('\n')
+    out = []
+    para = []
+
+    def flush_para():
+        if para:
+            joined = '\n'.join(para)
+            out.append(resolve_inline(joined, subs, ref_resolve))
+            del para[:]
+
+    i = 0
+    n = len(lines)
+    while i < n:
+        line = lines[i]
+
+        # Blank line: paragraph boundary.
+        if not line.strip():
+            flush_para()
+            out.append('')
+            i += 1
+            continue
+
+        # Section heading: text line followed by an underline of punctuation.
+        if (i + 1 < n and UNDERLINE_RE.match(lines[i + 1])
+                and not line.lstrip().startswith(('.. ', '* ', '- '))):
+            flush_para()
+            level = HEADING_LEVELS.get(lines[i + 1].strip()[0], 2)
+            title = resolve_inline(line.strip(), subs, ref_resolve)
+            out.append('#' * level + ' ' + title)
+            out.append('')
+            i += 2
+            continue
+
+        # Directives with a "::" (code-block, seealso, note, etc.).
+        dm = DIRECTIVE_RE.match(line)
+        if dm:
+            flush_para()
+            indent, name, arg = dm.group(1), dm.group(2), dm.group(3).strip()
+            i += 1
+            # Skip any directive option lines, then a single blank line.
+            while i < n and OPTION_RE.match(lines[i]):
+                i += 1
+            if i < n and not lines[i].strip():
+                i += 1
+            # Gather the indented body of the directive.
+            body = []
+            base = len(indent)
+            while i < n:
+                cur = lines[i]
+                if not cur.strip():
+                    body.append('')
+                    i += 1
+                    continue
+                cur_indent = len(cur) - len(cur.lstrip(' '))
+                if cur_indent <= base:
+                    break
+                body.append(cur)
+                i += 1
+            while body and not body[-1].strip():
+                body.pop()
+            body = _dedent(body)
+
+            if name in ('code-block', 'code'):
+                lang = arg if arg else ''
+                out.append('```' + lang)
+                out.extend(body)
+                out.append('```')
+                out.append('')
+            elif name == 'math':
+                out.append('```math')
+                out.extend(body)
+                out.append('```')
+                out.append('')
+            elif name in ('note', 'admonition', 'warning', 'important'):
+                if name == 'admonition':
+                    label = arg if arg else 'Note'
+                    inline = None
+                else:
+                    label = name.capitalize()
+                    inline = arg if arg else None  # content on the directive line
+                out.append('> **{}:**'.format(label))
+                # Resolve the whole body as one block (joined with newlines) so
+                # inline constructs that wrap across source lines -- multi-line
+                # :ref: roles and `text <url>`_ hyperlinks -- are handled, just
+                # like the top-level paragraph buffer above.
+                block = ([inline] if inline else []) + body
+                resolved = resolve_inline('\n'.join(block), subs, ref_resolve)
+                for b in resolved.split('\n'):
+                    out.append('> ' + b if b.strip() else '>')
+                out.append('')
+            elif name == 'seealso':
+                out.append('## See also')
+                out.append('')
+                for b in body:
+                    if b.strip():
+                        out.append(resolve_inline(b, subs, ref_resolve))
+                out.append('')
+            elif name in ('toctree',):
+                pass  # navigation: drop entirely
+            else:
+                # Unknown directive (e.g., list-table): keep its body as text.
+                for b in body:
+                    if b.strip():
+                        out.append(resolve_inline(b, subs, ref_resolve))
+                if body:
+                    out.append('')
+            continue
+
+        # Bare comment / anchor (".. _label:", ".. include_body",
+        # ".. mpi-bindings:", ".. some prose"): drop the comment and its
+        # indented continuation.
+        cm = COMMENT_RE.match(line)
+        if cm and not line.strip().startswith('.. |'):
+            flush_para()
+            base = len(cm.group(1))
+            i += 1
+            while i < n and (not lines[i].strip()
+                             or (len(lines[i]) - len(lines[i].lstrip(' ')) > base)):
+                if not lines[i].strip():
+                    break
+                i += 1
+            continue
+
+        # RST literal block: a line ending in '::' introduces an indented
+        # verbatim block.  Emit it as a fenced code block (verbatim, no inline
+        # resolution) rather than leaking the '::' marker into the Markdown.
+        stripped = line.rstrip()
+        if stripped.endswith('::'):
+            k = i + 1
+            while k < n and not lines[k].strip():
+                k += 1
+            cur_indent = len(line) - len(line.lstrip(' '))
+            if k < n and (len(lines[k]) - len(lines[k].lstrip(' '))) > cur_indent:
+                lead = stripped[:-2]
+                lead = lead.rstrip() if (not lead or lead.endswith(' ')) \
+                    else lead + ':'
+                if lead:
+                    para.append(lead)
+                flush_para()
+                j = k
+                body = []
+                while j < n:
+                    cur = lines[j]
+                    if not cur.strip():
+                        body.append('')
+                        j += 1
+                        continue
+                    if (len(cur) - len(cur.lstrip(' '))) <= cur_indent:
+                        break
+                    body.append(cur)
+                    j += 1
+                while body and not body[-1].strip():
+                    body.pop()
+                out.append('```')
+                out.extend(_dedent(body))
+                out.append('```')
+                out.append('')
+                i = j
+                continue
+
+        # Ordinary prose line: buffer until a paragraph boundary.
+        para.append(line)
+        i += 1
+
+    flush_para()
+
+    # Collapse 3+ blank lines to a single blank line.
+    md = '\n'.join(out)
+    md = re.sub(r'\n{3,}', '\n\n', md)
+    return md.strip() + '\n'
+
+
+# ---------------------------------------------------------------------------
+# Per-symbol Markdown page
+# ---------------------------------------------------------------------------
+
+def page_markdown(page_name, expanded, subs, ref_resolve, linkmaker, source_rel,
+                  page_rel):
+    """Render a per-symbol man3 page.  ``page_rel`` is the root-relative path of
+    the file this Markdown will live in, so its Canonical-HTML link resolves
+    correctly in a local (relative-link) build."""
+    body = rst_to_markdown(expanded, subs, ref_resolve)
+    html = linkmaker.link("man-openmpi/man3/{}.3.html".format(page_name),
+                          page_rel)
+    header = (
+        "<!-- Generated from {src}. Canonical HTML: {html} -->\n\n"
+        .format(src=source_rel, html=html))
+    return header + body
+
+
+# ---------------------------------------------------------------------------
+# Parameter / binding extraction
+# ---------------------------------------------------------------------------
+
+def parse_param_descriptions(rst_text):
+    """Return {param_name: description} from INPUT/OUTPUT PARAMETER bullets."""
+    descs = {}
+    bullet = re.compile(r'^\*\s+``([^`]+)``:\s*(.*)$')
+    for line in rst_text.split('\n'):
+        m = bullet.match(line.strip())
+        if m:
+            descs[m.group(1).strip()] = m.group(2).strip()
+    return descs
+
+
+def _normalize_direction(d):
+    if d is None:
+        return 'unknown'
+    val = d.value if hasattr(d, 'value') else str(d)
+    val = val.split('.')[-1].lower()
+    return val if val in ('in', 'out', 'inout') else 'unknown'
+
+
+# Maps a binding language to the suppress-token that hides a parameter from
+# that language's signature, so each binding can be given only its own
+# parameters (e.g. ierror appears in the Fortran bindings but not in C;
+# argc/argv appear only in C).
+_LANG_SUPPRESS_TOKEN = {
+    LANG_C: 'c_parameter',
+    LANG_MPIFH: 'f90_parameter',
+    LANG_USE_MPI: 'f90_parameter',
+    LANG_F08: 'f08_parameter',
+}
+
+
+def _fortran_intent(param_direction):
+    """Map a semantic direction to a Fortran INTENT attribute string."""
+    d = (param_direction or '').lower()
+    if d in ('in', 'out', 'inout'):
+        return 'INTENT({})'.format(d.upper())
+    return None
+
+
+def normalized_parameters(proc, param_descs, subs, ref_resolve):
+    """Build the normalized parameter list for a procedure.
+
+    Iterates the *full* per-procedure parameter metadata rather than the LIS
+    view: the LIS view (``express.lis``) suppresses parameters that do not
+    appear in the language-independent signature (e.g. MPI_Init's argc/argv
+    and ierror are all LIS-suppressed), which would drop real parameters and
+    yield empty/partial lists.  Using the full set keeps the catalog
+    signature/parameter authoritative.
+
+    Each returned entry carries the public schema fields plus, under a
+    ``_meta`` key, the upstream per-parameter facts (``suppress`` set and the
+    F08 ``optional`` flag, plus C const-ness) that :func:`standard_bindings`
+    needs to render an accurate *per-binding* parameter list.  ``_meta`` is
+    stripped before serialization (see :func:`_public_param`).
+
+    At the record level, ``type`` is the MPI semantic kind name (language
+    neutral) and ``direction`` is the semantic direction.  ``intent`` and
+    ``optional`` are left non-committal at the record level (``null`` and the
+    schema-sanctioned ``"unknown"`` sentinel respectively) because both are
+    per-binding properties; the precise values are emitted per binding.
+
+    Human descriptions come from the RST parameter bullets when present,
+    falling back to the upstream metadata description (and its kind default).
+    """
+    # The full parameter set (with semantic kinds) is only available on the
+    # raw parseset; the public binding views each filter a different subset.
+    # KINDS / the kind default-description map come from the same embedded
+    # pympistandard package that ``proc`` belongs to.
+    from pympistandard.storage import KINDS
+    from pympistandard.lis import _DEFAULT_DESCRIPTIONS
+
+    params = []
+    for p in proc._parseset.get('parameters', []):
+        name = p['name']
+        direction = _normalize_direction(p.get('lis_direction'))
+        kind_key = p.get('kind')
+        kind = KINDS[kind_key] if kind_key is not None else None
+        kind_name = getattr(kind, 'name', None) if kind is not None else None
+        desc = param_descs.get(name)
+        if not desc:
+            desc = p.get('desc') or None
+        if not desc and kind_name is not None:
+            desc = _DEFAULT_DESCRIPTIONS[kind_name] or None
+        if desc:
+            desc = resolve_inline(desc, subs, ref_resolve)
+        params.append({
+            "name": name,
+            "direction": direction,
+            "type": kind_name,
+            "intent": None,
+            "optional": "unknown",
+            "description": desc,
+            "_meta": {
+                "suppress": set((p.get('suppress') or '').split()),
+                "optional": bool(p.get('optional')),
+                "constant": bool(p.get('constant')),
+                "param_direction": p.get('param_direction'),
+            },
+        })
+    return params
+
+
+def _public_param(param):
+    """Return a copy of a normalized parameter without the internal ``_meta``."""
+    return {k: v for k, v in param.items() if k != '_meta'}
+
+
+def _binding_parameters(params, language):
+    """Project the normalized parameter list onto a single binding.
+
+    Drops parameters suppressed for ``language`` and fills in the per-binding
+    ``intent`` (Fortran INTENT / C const-ness) and ``optional`` (the F08
+    OPTIONAL attribute) that are ambiguous on the language-neutral list.
+    """
+    token = _LANG_SUPPRESS_TOKEN.get(language)
+    out = []
+    for p in params:
+        meta = p['_meta']
+        if token is not None and token in meta['suppress']:
+            continue
+        bp = _public_param(p)
+        if language == LANG_C:
+            bp['intent'] = 'const' if meta['constant'] else None
+            # C has no optional-argument concept for these parameters.
+            bp['optional'] = False
+        elif language == LANG_F08:
+            bp['intent'] = _fortran_intent(meta['param_direction'])
+            bp['optional'] = meta['optional']
+        else:  # mpif.h / use mpi: positional, no OPTIONAL attribute
+            bp['intent'] = _fortran_intent(meta['param_direction'])
+            bp['optional'] = False
+        out.append(bp)
+    return out
+
+
+def standard_bindings(proc, params, name):
+    """Build the bindings array for a standard procedure (proper-case name).
+
+    Each binding gets only its own parameters (projected from the
+    language-neutral ``params`` via :func:`_binding_parameters`): e.g. the C
+    binding excludes the Fortran-only ``ierror`` and the Fortran bindings
+    exclude the C-only ``argc``/``argv``.
+    """
+    bindings = []
+
+    c = common.c_binding(proc)
+    if c is not None:
+        c_params = _binding_parameters(params, LANG_C)
+        bindings.append({"language": LANG_C, "procedure": name,
+                         "signature": c, "large_count": False,
+                         "return_convention": "int return code",
+                         "parameters": c_params})
+        clarge = common.c_binding_large(proc)
+        if clarge is not None:
+            bindings.append({"language": LANG_C, "procedure": name + "_c",
+                             "signature": clarge, "large_count": True,
+                             "return_convention": "int return code",
+                             "parameters": c_params})
+
+    f90 = common.f90_binding(proc)
+    if f90 is not None:
+        for lang in (LANG_MPIFH, LANG_USE_MPI):
+            bindings.append({"language": lang, "procedure": name,
+                             "signature": f90, "large_count": False,
+                             "return_convention": "ierror argument",
+                             "parameters": _binding_parameters(params, lang)})
+
+    f08 = common.f08_binding(proc)
+    if f08 is not None:
+        f08_params = _binding_parameters(params, LANG_F08)
+        bindings.append({"language": LANG_F08, "procedure": name,
+                         "signature": f08, "large_count": False,
+                         "return_convention": "ierror argument",
+                         "parameters": f08_params})
+        f08large = common.f08_binding_large(proc)
+        if f08large is not None:
+            bindings.append({"language": LANG_F08, "procedure": name,
+                             "signature": f08large, "large_count": True,
+                             "return_convention": "ierror argument",
+                             "parameters": f08_params})
+    return bindings
+
+
+def categorize(name):
+    if name in COLLECTIVE_NAMES:
+        return "collective"
+    if name in POINT_TO_POINT_NAMES:
+        return "point-to-point"
+    if name in PROCESS_NAMES:
+        return "process"
+    if name in RMA_NAMES:
+        return "rma"
+    for prefix, cat in CATEGORY_PREFIXES:
+        if name.startswith(prefix):
+            return cat
+    if name.startswith(("MPIX_", "OMPI_")):
+        return "extension"
+    return "other"
+
+
+def _extract_declaration(code_lines, name):
+    """Return only the C declaration of ``name`` from a code block's lines.
+
+    Extension/deprecated man pages sometimes put several function declarations
+    in one SYNTAX code block (e.g. MPIX_Comm_agree and MPIX_Comm_iagree); a
+    per-procedure record should carry only its own signature, not all of them.
+    Falls back to the whole block if ``name`` is not found.
+    """
+    pat = re.compile(r'\b' + re.escape(name) + r'\s*\(')
+    start = None
+    for i, ln in enumerate(code_lines):
+        if pat.search(ln):
+            start = i
+            break
+    if start is None:
+        return '\n'.join(code_lines)
+    out = []
+    depth = 0
+    for ln in code_lines[start:]:
+        out.append(ln)
+        depth += ln.count('(') - ln.count(')')
+        if depth <= 0:
+            break
+    return '\n'.join(out)
+
+
+def extension_bindings_from_rst(rst_text, name=None):
+    """Best-effort: pull the C signature out of an extension page's code block.
+
+    If ``name`` is given and the block declares several procedures, return only
+    the declaration matching ``name``.
+    """
+    lines = rst_text.split('\n')
+    for i, line in enumerate(lines):
+        m = DIRECTIVE_RE.match(line)
+        if m and m.group(2) in ('code-block', 'code'):
+            base = len(m.group(1))
+            j = i + 1
+            while j < len(lines) and not lines[j].strip():
+                j += 1
+            # Body lines are those indented deeper than the directive itself
+            # (man-page code blocks use a 3-space indent, not necessarily 4).
+            body = []
+            while j < len(lines):
+                cur = lines[j]
+                if not cur.strip():
+                    j += 1
+                    continue
+                indent = len(cur) - len(cur.lstrip(' \t'))
+                if indent <= base:
+                    break
+                body.append(cur.strip())
+                j += 1
+            code_lines = [b for b in body if not b.startswith('#')]
+            if name:
+                sig = _extract_declaration(code_lines, name).strip()
+            else:
+                sig = '\n'.join(code_lines).strip()
+            if sig:
+                return [{"language": LANG_C, "procedure": None,
+                         "signature": sig, "large_count": False,
+                         "return_convention": "int return code",
+                         "parameters": []}]
+    return []
+
+
+def parse_seealso(rst_text):
+    """Collect the symbol names referenced in a page's .. seealso:: block."""
+    names = []
+    lines = rst_text.split('\n')
+    in_block = False
+    for line in lines:
+        if line.strip().startswith('.. seealso::'):
+            in_block = True
+            continue
+        if in_block:
+            if line.strip() and not line.startswith((' ', '\t')):
+                break
+            for m in re.finditer(r':ref:`([^`<]+?)(?:\s*<[^`>]+>)?`', line):
+                nm = m.group(1).strip().replace('(3)', '').strip()
+                if nm and nm not in names:
+                    names.append(nm)
+    return names
+
+
+def short_description(rst_text, subs, ref_resolve):
+    """Extract the one-line short description that follows the page title."""
+    lines = rst_text.split('\n')
+    i = 0
+    n = len(lines)
+    # Skip to past the title underline.
+    while i + 1 < n and not (lines[i].strip() and UNDERLINE_RE.match(lines[i + 1])):
+        i += 1
+    i += 2
+    # Find the first non-blank, non-directive paragraph.
+    buf = []
+    while i < n:
+        s = lines[i].strip()
+        if not s:
+            if buf:
+                break
+            i += 1
+            continue
+        if s.startswith('.. ') or s == '::':
+            # Skip directives and a bare RST literal-block marker; the real
+            # short description may follow inside the literal block.
+            i += 1
+            continue
+        buf.append(s)
+        i += 1
+    text = ' '.join(buf)
+    text = resolve_inline(text, subs, ref_resolve)
+    # Drop a leading "NAME — " prefix for brevity.
+    text = re.sub(r'^\[?[A-Za-z_0-9]+\]?(\([^)]*\))?\s*[—-]\s*', '', text)
+    return text.strip()
+
+
+def best_effort_record(name, kind, category, expanded, docset, urls,
+                       source_rel, errors_html, documented_with, bindings=None):
+    """Build a best-effort catalog record for a procedure whose metadata is not
+    in pympistandard (Open MPI extensions, or deprecated/removed MPI APIs).
+
+    The signature is recovered from the man-page RST rather than the structured
+    metadata, so structured parameter fields are left empty (``unknown``).
+    """
+    if bindings is None:
+        bindings = extension_bindings_from_rst(expanded, name)
+    for b in bindings:
+        b["procedure"] = name
+    languages = sorted({b['language'] for b in bindings})
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "project": "open-mpi",
+        "docset": docset,
+        "name": name,
+        "kind": kind,
+        "standard": None,
+        "category": category,
+        "languages": languages,
+        "bindings": bindings,
+        "parameters": [],
+        "semantics": None,
+        "errors": {"convention": None, "url": errors_html},
+        "seealso": parse_seealso(expanded),
+        "documented_with": documented_with,
+        "urls": urls,
+        "sources": {"rst": source_rel, "binding_metadata": "rst"},
+    }
+
+
+# ---------------------------------------------------------------------------
+# Manifest helpers
+# ---------------------------------------------------------------------------
+
+def media_type_for(path):
+    return MEDIA_TYPES.get(os.path.splitext(path)[1], 'application/octet-stream')
+
+
+def estimate_tokens(data_bytes):
+    # Coarse heuristic: ~4 bytes per token.
+    return (len(data_bytes) + 3) // 4
+
+
+# Absolute paths of every artifact written this run; used to build the
+# manifest and to prune stale files left from previous runs.
+WRITTEN_PATHS = []
+
+
+def write_file(path, text):
+    path = os.path.abspath(path)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    data = text.encode('utf-8')
+    WRITTEN_PATHS.append(path)
+    # Only write when changed (deterministic, avoids needless churn / mtime
+    # bumps so incremental docs builds don't see spurious changes).
+    if os.path.exists(path):
+        with open(path, 'rb') as fp:
+            if fp.read() == data:
+                return
+    with open(path, 'wb') as fp:
+        fp.write(data)
+
+
+def prune_stale(outdir):
+    """Remove files under outdir that were not written this run, plus empties."""
+    keep = set(WRITTEN_PATHS)
+    for root, _dirs, files in os.walk(outdir):
+        for fn in files:
+            full = os.path.abspath(os.path.join(root, fn))
+            if full not in keep:
+                os.remove(full)
+    for root, _dirs, _files in os.walk(outdir, topdown=False):
+        if os.path.abspath(root) != os.path.abspath(outdir) and not os.listdir(root):
+            os.rmdir(root)
+
+
+# ---------------------------------------------------------------------------
+# Command (man1) man pages
+# ---------------------------------------------------------------------------
+
+def command_man_pages(srcdir, builddir, llms_dir, subs, ref_resolve, linkmaker):
+    """Convert the section-1 command man pages (man1) to Markdown.
+
+    These document Open MPI commands (mpirun, ompi_info, the wrapper
+    compilers, ...), not MPI APIs, so they get a Markdown corpus only -- no
+    JSONL catalog records.  Returns the sorted list of page names written
+    (e.g. "mpirun.1") for indexing in llms.txt.  The bare ".so" redirect
+    stubs (mpicc.1 -> ompi-wrapper-compiler.1) are not RST and are skipped.
+
+    ``ref_resolve`` must resolve :ref: links from the man1 page location, and
+    the Canonical-HTML header link is built from that same location, so a local
+    (relative-link) build resolves correctly.
+    """
+    man1_src = os.path.join(srcdir, 'man-openmpi', 'man1')
+    if not os.path.isdir(man1_src):
+        return []
+    pages = []
+    for fn in sorted(os.listdir(man1_src)):
+        if fn == 'index.rst' or not fn.endswith('.1.rst'):
+            continue
+        name = fn[:-len('.rst')]  # "mpirun.1.rst" -> "mpirun.1"
+        rst_path = os.path.join(man1_src, fn)
+        source_rel = os.path.relpath(rst_path, srcdir)
+        page_rel = "llms/man-openmpi/man1/{}.md".format(name)
+        with open(rst_path, encoding='utf-8') as fp:
+            raw = fp.read()
+        expanded = expand_includes(raw, rst_path, srcdir, builddir)
+        body = rst_to_markdown(expanded, subs, ref_resolve)
+        html = linkmaker.link("man-openmpi/man1/{}.html".format(name), page_rel)
+        header = ("<!-- Generated from {src}. Canonical HTML: {html} -->\n\n"
+                  .format(src=source_rel, html=html))
+        write_file(os.path.join(llms_dir, 'man-openmpi', 'man1',
+                                '{}.md'.format(name)), header + body)
+        pages.append(name)
+    return pages
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    args = setup_cli()
+    srcdir = os.path.abspath(args.srcdir)
+    builddir = os.path.abspath(args.builddir)
+    top_srcdir = os.path.dirname(srcdir)
+    outdir = os.path.abspath(args.outdir) if args.outdir \
+        else os.path.join(builddir, 'llms-build')
+    llms_dir = os.path.join(outdir, 'llms')
+
+    version_info = common.ompi_version_info(top_srcdir)
+
+    # Resolve the link strategy for this build (see the LinkMaker docstring).
+    #
+    # A local build from git produces the artifacts for a *local* LLM/tool that
+    # reads the files straight off disk: there is no docs.open-mpi.org site in
+    # play, so the RTD URL scheme is irrelevant and links are made RELATIVE to
+    # each file (a self-contained, portable tree).  A Read the Docs build
+    # publishes to docs.open-mpi.org/en/<slug>/, so there links are ABSOLUTE and
+    # use that published version slug (e.g. .../en/main/ for the "main" branch).
+    # An explicit --url-base / OMPI_LLM_URL_BASE override forces absolute links.
+    rtd_slug = os.environ.get('READTHEDOCS_VERSION')
+    explicit_base = args.url_base or os.environ.get('OMPI_LLM_URL_BASE')
+    if explicit_base:
+        url_base = explicit_base
+    elif os.environ.get('READTHEDOCS_CANONICAL_URL'):
+        url_base = os.environ['READTHEDOCS_CANONICAL_URL']
+    elif rtd_slug:
+        url_base = "https://docs.open-mpi.org/en/{}".format(rtd_slug)
+    else:
+        url_base = None  # local build -> relative links
+    lm = LinkMaker(url_base)
+
+    subs = build_substitutions(version_info)
+    std = common.load_pympistandard(srcdir)
+
+    man3_src = os.path.join(srcdir, 'man-openmpi', 'man3')
+    page_re = re.compile(r'^((?:MPI_|MPIX_|OMPI_).*)\.3\.rst$')
+    page_files = {}
+    for fn in sorted(os.listdir(man3_src)):
+        m = page_re.match(fn)
+        if m:
+            page_files[m.group(1)] = os.path.join(man3_src, fn)
+    known_pages = set(page_files.keys())
+    # :ref: links must resolve from the location of the file they end up in.
+    # The per-symbol man3 pages, the man1 pages, and the files that live
+    # directly under llms/ (aggregate corpus, language corpora, JSONL records)
+    # are at different depths, so each gets a resolver bound to its own
+    # location.  (In an absolute/RTD build all three produce identical links.)
+    res_man3 = make_ref_resolver(known_pages, lm, "llms/man-openmpi/man3/x")
+    res_man1 = make_ref_resolver(known_pages, lm, "llms/man-openmpi/man1/x")
+    res_llms = make_ref_resolver(known_pages, lm, "llms/x")
+
+    # Map each procedure (lowercase) to its co-documented procedures.
+    directives = common.read_rst_man_pages(srcdir)
+    lower_to_actual = {p.lower(): p for p in known_pages}
+    co_docs = {}
+    for _page, procs in directives.items():
+        if not procs:
+            continue
+        for p in procs:
+            co_docs[p] = [lower_to_actual.get(q, q) for q in procs if q != p]
+
+    docset = {"ompi_version": version_info['ompi_version'],
+              "ompi_series": version_info['ompi_series'],
+              "schema_version": SCHEMA_VERSION}
+    # The JSONL catalog lives at llms/openmpi-mpi-api.jsonl, so its record URLs
+    # are resolved from there.
+    jsonl_rel = "llms/openmpi-mpi-api.jsonl"
+    errors_html = lm.link("man-openmpi/man3/MPI_Errors.3.html", jsonl_rel)
+
+    records = []
+    page_md = {}      # page_name -> per-symbol-page markdown (man3 depth)
+    agg_md = {}       # page_name -> same body rendered for the llms/ corpus
+    short_desc = {}   # page_name -> short description
+
+    for name in sorted(page_files):
+        rst_path = page_files[name]
+        source_rel = os.path.relpath(rst_path, srcdir)
+        with open(rst_path, encoding='utf-8') as fp:
+            raw = fp.read()
+        expanded = expand_includes(raw, rst_path, srcdir, builddir)
+
+        page_rel = "llms/man-openmpi/man3/{}.3.md".format(name)
+        page_md[name] = page_markdown(name, expanded, subs, res_man3,
+                                      lm, source_rel, page_rel)
+        # The same body is inlined into the aggregate corpus at llms/, a
+        # different depth, so in a relative-link build it must be re-rendered
+        # from that location; in an absolute build the links are identical, so
+        # reuse the per-symbol render.
+        if lm.absolute:
+            agg_md[name] = page_md[name]
+        else:
+            agg_md[name] = page_markdown(name, expanded, subs, res_llms,
+                                         lm, source_rel,
+                                         "llms/openmpi-mpi-api.md")
+        short_desc[name] = short_description(expanded, subs, res_llms)
+
+        low = name.lower()
+        urls = {
+            "html": lm.link("man-openmpi/man3/{}.3.html".format(name),
+                            jsonl_rel),
+            "markdown": lm.link("llms/man-openmpi/man3/{}.3.md".format(name),
+                                jsonl_rel),
+        }
+        if low in std.PROCEDURES:
+            proc = std.PROCEDURES[low]
+            params = normalized_parameters(
+                proc, parse_param_descriptions(expanded), subs, res_llms)
+            bindings = standard_bindings(proc, params, name)
+            params = [_public_param(p) for p in params]
+            languages = sorted({b['language'] for b in bindings})
+            rec = {
+                "schema_version": SCHEMA_VERSION,
+                "project": "open-mpi",
+                "docset": docset,
+                "name": name,
+                "kind": "standard",
+                "standard": {"version": None},
+                "category": categorize(name),
+                "languages": languages,
+                "bindings": bindings,
+                "parameters": params,
+                "semantics": {
+                    "blocking": None,
+                    "collective": name in COLLECTIVE_NAMES,
+                    "local": None,
+                    "initialization_required": None,
+                    "threading_notes": None,
+                },
+                "errors": {
+                    "convention": "C: int return code; Fortran: ierror argument.",
+                    "url": errors_html,
+                },
+                "seealso": parse_seealso(expanded),
+                "documented_with": co_docs.get(low, []),
+                "urls": urls,
+                "sources": {"rst": source_rel, "binding_metadata": "pympistandard"},
+            }
+            records.append(rec)
+        elif name.startswith(("MPIX_", "OMPI_")):
+            records.append(best_effort_record(
+                name, "extension", "extension", expanded, docset, urls,
+                source_rel, errors_html, co_docs.get(low, [])))
+        else:
+            # An MPI_* page not known to pympistandard documents a
+            # deprecated/removed procedure when a signature can be recovered
+            # from its RST; otherwise it is an overview/non-procedure page
+            # (e.g. MPI_T.3, MPI_Errors.3) and gets Markdown only, no record.
+            ext_bindings = (extension_bindings_from_rst(expanded, name)
+                            if name.startswith("MPI_") else [])
+            # Only a real procedure page: its recovered signature must actually
+            # declare this name (filters overview pages such as MPI_T.3 whose
+            # code blocks contain unrelated example code).
+            declares = ext_bindings and re.search(
+                r'\b' + re.escape(name) + r'\s*\(', ext_bindings[0]['signature'])
+            if declares:
+                records.append(best_effort_record(
+                    name, "deprecated", categorize(name), expanded, docset,
+                    urls, source_rel, errors_html, co_docs.get(low, []),
+                    bindings=ext_bindings))
+
+    records.sort(key=lambda r: r['name'])
+
+    # --- Write per-symbol Markdown pages ---
+    for name in sorted(page_md):
+        write_file(os.path.join(llms_dir, 'man-openmpi', 'man3',
+                                '{}.3.md'.format(name)), page_md[name])
+
+    # --- Write command (man1) Markdown pages (corpus only, no records) ---
+    man1_pages = command_man_pages(srcdir, builddir, llms_dir, subs,
+                                   res_man1, lm)
+
+    # --- Write the JSONL catalog ---
+    jsonl = ''.join(json.dumps(r, ensure_ascii=False, sort_keys=True) + '\n'
+                    for r in records)
+    write_file(os.path.join(llms_dir, 'openmpi-mpi-api.jsonl'), jsonl)
+
+    # --- Aggregate Markdown corpora ---
+    header = ("# Open MPI MPI API reference ({ver})\n\n"
+              "Generated for LLM and retrieval consumers. The MPI Standard is "
+              "authoritative for portable MPI semantics; `MPIX_*` and `OMPI_*` "
+              "are Open MPI extensions.\n\n"
+              .format(ver=version_info['ompi_version']))
+    all_md = header + '\n\n---\n\n'.join(agg_md[n] for n in sorted(agg_md))
+    write_file(os.path.join(llms_dir, 'openmpi-mpi-api.md'), all_md)
+
+    lang_corpora = {
+        LANG_C: 'openmpi-mpi-api-c.md',
+        LANG_MPIFH: 'openmpi-mpi-api-fortran-mpifh.md',
+        LANG_USE_MPI: 'openmpi-mpi-api-fortran-use-mpi.md',
+        LANG_F08: 'openmpi-mpi-api-fortran-use-mpi-f08.md',
+    }
+    lang_titles = {
+        LANG_C: 'C', LANG_MPIFH: "Fortran (mpif.h)",
+        LANG_USE_MPI: "Fortran (use mpi)", LANG_F08: "Fortran (use mpi_f08)",
+    }
+    lang_fence = {LANG_C: 'c', LANG_MPIFH: 'fortran',
+                  LANG_USE_MPI: 'fortran', LANG_F08: 'fortran'}
+    for lang, fname in lang_corpora.items():
+        parts = ["# Open MPI MPI API reference — {} interface ({})\n"
+                 .format(lang_titles[lang], version_info['ompi_version'])]
+        for rec in records:
+            blist = [b for b in rec['bindings'] if b['language'] == lang]
+            if not blist:
+                continue
+            parts.append("## {}\n".format(rec['name']))
+            sd = short_desc.get(rec['name'])
+            if sd:
+                parts.append(sd + "\n")
+            for b in blist:
+                parts.append("```{}\n{}\n```\n".format(lang_fence[lang],
+                                                       b['signature']))
+            parts.append("Documentation: {}\n".format(rec['urls']['html']))
+        write_file(os.path.join(llms_dir, fname), '\n'.join(parts) + '\n')
+
+    # --- Copy curated source files (those that exist) ---
+    llms_src = os.path.join(srcdir, 'llms-src')
+    present_curated = set()
+    for fn in CURATED_FILES:
+        src = os.path.join(llms_src, fn)
+        if os.path.isfile(src):
+            with open(src, 'rb') as fp:
+                write_file(os.path.join(llms_dir, fn),
+                           fp.read().decode('utf-8'))
+            present_curated.add(fn)
+
+    # --- versioned llms.txt (timestamp-free, listable in the manifest) ---
+    llms_txt = build_llms_txt(version_info, lm, rtd_slug, present_curated,
+                              man1_pages)
+    write_file(os.path.join(outdir, 'llms.txt'), llms_txt)
+
+    # --- Manifest (the only artifact carrying build identity) ---
+    manifest = build_manifest(outdir, lm, version_info, top_srcdir)
+    write_file(os.path.join(llms_dir, 'openmpi-docs-manifest.json'),
+               json.dumps(manifest, ensure_ascii=False, indent=1,
+                          sort_keys=True) + '\n')
+
+    # Remove any stale files from a previous run so the published tree matches
+    # the manifest exactly.
+    prune_stale(outdir)
+
+    print("  GENERATE LLM docs ({} records, {} pages)"
+          .format(len(records), len(page_md)))
+
+
+def _this_build_description(version_info, linkmaker, rtd_slug):
+    """One sentence identifying which build this llms.txt belongs to.
+
+    For a Read the Docs "main" build the slug is "main" but the version it
+    represents is the VERSION-file series, so both are named (the dual
+    attribution requested in the spec).  A local build has no published slug;
+    it is identified by its version and noted as relative/local.
+    """
+    series = version_info['ompi_series']        # e.g. "v6.1.x"
+    version = version_info['ompi_version']       # e.g. "6.1.0"
+    if not linkmaker.absolute:
+        return ("a local build of Open MPI {} (the {} series), built from a git "
+                "checkout. The links in this file are relative to this file's "
+                "own location: this build targets a local tool that reads these "
+                "files directly off disk, so it deliberately does not use the "
+                "docs.open-mpi.org URL scheme.".format(version, series))
+    if rtd_slug == 'main':
+        return ('the "main" git branch (the development tip), which currently '
+                'identifies itself as the Open MPI {} series. It is published '
+                'at https://docs.open-mpi.org/en/main/ .'.format(series))
+    if rtd_slug:
+        return ('Open MPI {slug}, published at '
+                'https://docs.open-mpi.org/en/{slug}/ .'.format(slug=rtd_slug))
+    return 'Open MPI {} (the {} series).'.format(version, series)
+
+
+def build_llms_txt(version_info, linkmaker, rtd_slug, present_curated,
+                   man1_pages=None):
+    v = version_info['ompi_version']
+
+    def link(target):
+        # All links in llms.txt are resolved from the file's own location
+        # (the documentation version root, where llms.txt lives).
+        return linkmaker.link(target, "llms.txt")
+
+    lines = [
+        "# Open MPI {}".format(v), "",
+        "Open MPI is an open source implementation of the Message Passing "
+        "Interface (MPI) specification. This file indexes LLM-friendly "
+        "documentation artifacts for this documentation version.", "",
+        "## About this file", "",
+        "This is the llms.txt for {}".format(
+            _this_build_description(version_info, linkmaker, rtd_slug)), "",
+        "Open MPI publishes a separate set of these LLM-friendly artifacts for "
+        "each documentation version. For Open MPI v5.0.0 and later they all "
+        "follow the same URL scheme:", "",
+        "    https://docs.open-mpi.org/en/VERSION_SLUG/", "",
+        "where VERSION_SLUG is either:", "",
+        "- `main` --- the build from Open MPI's `main` git branch (the "
+        "development tip); or",
+        "- `vA.B.C` --- where A and B are the major and minor version numbers. "
+        "If C is `x` (e.g. `v6.1.x`) it is the build from that release branch; "
+        "if C is an integer (e.g. `v6.1.0`) it is the build from that specific "
+        "git-tagged release.", "",
+        "If you found this file but are looking for the LLM documentation of a "
+        "different Open MPI version, substitute the desired VERSION_SLUG into "
+        "the scheme above (for example, "
+        "https://docs.open-mpi.org/en/main/llms.txt).", "",
+        "Documentation for Open MPI versions older than v5.0.0 is not published "
+        "in this format; for those, see "
+        "https://github.com/open-mpi/ompi/blob/v4.1.x/README , "
+        "https://www.open-mpi.org/faq/ , and https://www.open-mpi.org/doc/ .",
+        "",
+        "- The MPI Standard (https://www.mpi-forum.org/docs/) is authoritative "
+        "for portable MPI semantics.",
+        "- `MPIX_*` and `OMPI_*` APIs are Open MPI extensions, not portable "
+        "MPI Standard APIs.", "",
+        "## API catalog and corpora", "",
+        "- [Machine-readable API catalog (JSONL)]({})".format(
+            link("llms/openmpi-mpi-api.jsonl")),
+        "- [Aggregate Markdown corpus]({})".format(
+            link("llms/openmpi-mpi-api.md")),
+        "- [C interface]({})".format(link("llms/openmpi-mpi-api-c.md")),
+        "- [Fortran mpif.h interface]({})".format(
+            link("llms/openmpi-mpi-api-fortran-mpifh.md")),
+        "- [Fortran use mpi interface]({})".format(
+            link("llms/openmpi-mpi-api-fortran-use-mpi.md")),
+        "- [Fortran use mpi_f08 interface]({})".format(
+            link("llms/openmpi-mpi-api-fortran-use-mpi-f08.md")),
+    ]
+    # Only advertise curated artifacts that are actually published.
+    if 'openmpi-mpi-interface-guide.md' in present_curated:
+        lines.append("- [Interface selection guide]({})".format(
+            link("llms/openmpi-mpi-interface-guide.md")))
+    if 'openmpi-mpi-examples.md' in present_curated:
+        lines.append("- [Curated examples]({})".format(
+            link("llms/openmpi-mpi-examples.md")))
+    lines += [
+        "- [Artifact manifest]({})".format(
+            link("llms/openmpi-docs-manifest.json")), "",
+    ]
+    # Runtime introspection: the artifacts above describe the API for this
+    # version; a *specific installation* (version, build config, available
+    # components, and the run-time MCA parameters its components expose) is
+    # discovered from that installation with the ompi_info command.
+    if 'openmpi-runtime-introspection.md' in present_curated:
+        lines += [
+            "## Runtime introspection (installed Open MPI)", "",
+            "The artifacts above describe the MPI API for this version. To "
+            "inspect a *specific* installation --- its exact version, build "
+            "configuration, available MCA components, and the full set of "
+            "run-time tunables (MCA parameters) --- run the `ompi_info` command "
+            "on that installation; `ompi_info --all --parsable` emits a "
+            "comprehensive, self-describing, machine-readable dump.", "",
+            "- [Runtime introspection with ompi_info]({})".format(
+                link("llms/openmpi-runtime-introspection.md")), "",
+        ]
+    # Command (man1) man pages: a Markdown corpus, no catalog records.
+    if man1_pages:
+        lines += ["## Command man pages", ""]
+        lines += ["- [{n}]({u})".format(
+            n=n, u=link("llms/man-openmpi/man1/{}.md".format(n)))
+            for n in man1_pages]
+        lines += [""]
+    lines += [
+        "## Human-facing documentation", "",
+        "- [Building MPI applications]({})".format(
+            link("building-apps/index.html")),
+        "- [Launching MPI applications]({})".format(
+            link("launching-apps/index.html")),
+        "- [Tuning MPI applications]({})".format(
+            link("tuning-apps/index.html")),
+    ]
+    return '\n'.join(lines) + '\n'
+
+
+ALL_LANGS_LIST = [LANG_C, LANG_MPIFH, LANG_USE_MPI, LANG_F08]
+# Artifacts whose content is specific to a language/interface set.
+ARTIFACT_LANGUAGES = {
+    'llms/openmpi-mpi-api.md': ALL_LANGS_LIST,
+    'llms/openmpi-mpi-api.jsonl': ALL_LANGS_LIST,
+    'llms/openmpi-mpi-api-c.md': [LANG_C],
+    'llms/openmpi-mpi-api-fortran-mpifh.md': [LANG_MPIFH],
+    'llms/openmpi-mpi-api-fortran-use-mpi.md': [LANG_USE_MPI],
+    'llms/openmpi-mpi-api-fortran-use-mpi-f08.md': [LANG_F08],
+}
+
+
+def build_manifest(outdir, linkmaker, version_info, top_srcdir):
+    manifest_rel = 'llms/openmpi-docs-manifest.json'
+    # Inventory exactly the artifacts written this run (so stale leftovers are
+    # never listed). The manifest is not yet written here, so it is naturally
+    # excluded; guard against it anyway.
+    artifacts = []
+    seen = set()
+    for full in WRITTEN_PATHS:
+        rel = os.path.relpath(full, outdir)
+        if rel == manifest_rel or rel in seen:
+            continue
+        seen.add(rel)
+        with open(full, 'rb') as fp:
+            data = fp.read()
+        entry = {
+            # path stays root-relative (the validator locates files by it);
+            # only the URL follows the build's link strategy.
+            "path": rel,
+            "url": linkmaker.link(rel, manifest_rel),
+            "media_type": media_type_for(full),
+            "sha256": hashlib.sha256(data).hexdigest(),
+            "bytes": len(data),
+            "tokens_estimate": estimate_tokens(data),
+        }
+        mm = re.match(r'llms/man-openmpi/man3/(.+)\.3\.md$', rel)
+        if mm:
+            entry["symbols"] = [mm.group(1)]
+        if rel in ARTIFACT_LANGUAGES:
+            entry["languages"] = ARTIFACT_LANGUAGES[rel]
+        artifacts.append(entry)
+    artifacts.sort(key=lambda e: e['path'])
+
+    manifest = {
+        "artifact_schema_version": ARTIFACT_SCHEMA_VERSION,
+        "project": "open-mpi",
+        "ompi_version": version_info['ompi_version'],
+        "ompi_series": version_info['ompi_series'],
+        "rtd_version_slug": os.environ.get('READTHEDOCS_VERSION'),
+        "git_commit": common.git_commit(top_srcdir),
+        "git_describe": common.git_describe(top_srcdir),
+        "generated_at": common.generated_at_utc(top_srcdir),
+        "artifacts": artifacts,
+    }
+    return manifest
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/generate-mpi-man3-bindings.py b/docs/generate-mpi-man3-bindings.py
index cc922a0af42..33713163565 100755
--- a/docs/generate-mpi-man3-bindings.py
+++ b/docs/generate-mpi-man3-bindings.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 #
-# Copyright (c) 2025 Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2025-2026 Jeffrey M. Squyres.  All rights reserved.
 #
 # $COPYRIGHT$
 #
@@ -17,16 +17,16 @@
 #
 # Using this method, we can emit both "regular" and "embiggened"
 # versions of each API (if an "embiggened" version exists).
+#
+# Logic that is shared with the LLM-friendly documentation generator
+# (parsing the .. mpi-bindings: directives, loading pympistandard, and
+# rendering the C/F90/F08 binding strings) lives in ompi_docs_common.py.
 
-import re
 import os
-import sys
 import textwrap
 import argparse
 
-from pathlib import Path
-from collections import defaultdict
-from pprint import pprint
+import ompi_docs_common as common
 
 #----------------
 
@@ -94,8 +94,8 @@ def generate(func_name_arg, output_dir, directives):
     # C bindings
     emitted_header = False
     for data in func_names_data:
-        binding = str(data.express.iso_c)
-        if binding and len(binding) > 0 and binding != 'None':
+        binding = common.c_binding(data)
+        if binding is not None:
             have_binding = True
             if not emitted_header:
                 out.append('C Syntax')
@@ -105,23 +105,15 @@ def generate(func_name_arg, output_dir, directives):
                 out.append(blank)
                 emitted_header = True
 
-            # Per
-            # https://github.com/mpi-forum/pympistandard/issues/25,
-            # there's a bug that the binding for MPI_Pcontrol returns
-            # a string containing "\ldots", not "...".  Do a manual
-            # replacement here.
-            binding = binding.replace(r'\ldots', '...')
-
             line = textwrap.fill(binding, width=72,
                                  initial_indent='    ',
                                  subsequent_indent = '        ')
             out.append(line)
             out.append(blank)
 
-            if data.has_embiggenment():
-                binding = str(data.express.embiggen.iso_c)
-                binding = binding.replace(r'\ldots', '...')
-                line = textwrap.fill(binding, width=72,
+            large = common.c_binding_large(data)
+            if large is not None:
+                line = textwrap.fill(large, width=72,
                                      initial_indent='    ',
                                      subsequent_indent = '        ')
                 out.append(line)
@@ -131,8 +123,8 @@ def generate(func_name_arg, output_dir, directives):
     # Note: the f90 bindings were not embiggened
     emitted_header = False
     for data in func_names_data:
-        binding = str(data.express.f90)
-        if binding and len(binding) > 0 and binding != 'None':
+        binding = common.f90_binding(data)
+        if binding is not None:
             have_binding = True
             if not emitted_header:
                 out.append('Fortran Syntax')
@@ -152,8 +144,8 @@ def generate(func_name_arg, output_dir, directives):
     # F08 bindings
     emitted_header = False
     for data in func_names_data:
-        binding = str(data.express.f08)
-        if binding and len(binding) > 0 and binding != 'None':
+        binding = common.f08_binding(data)
+        if binding is not None:
             have_binding = True
             if not emitted_header:
                 out.append('Fortran 2008 Syntax')
@@ -169,9 +161,9 @@ def generate(func_name_arg, output_dir, directives):
                 out.append(f'    {line}')
             out.append(blank)
 
-            if data.has_embiggenment():
-                binding = str(data.express.embiggen.f08)
-                lines = binding.split('\n')
+            large = common.f08_binding_large(data)
+            if large is not None:
+                lines = large.split('\n')
                 for line in lines:
                     out.append(f'    {line}')
                 out.append(blank)
@@ -199,44 +191,6 @@ def generate(func_name_arg, output_dir, directives):
 
 #----------------
 
-# Some existing .3.rst man pages actually contain the docs for
-# multiple MPI_* API functions.  Read the .3.rst files and look for
-# directives that mean "this file contains documentation for all these
-# MPI API functions".
-def read_rst_man_pages(src_dir):
-    directives = {}
-    prog = re.compile(r'^MPI_.*\.3\.rst$')
-
-    man3_dir = Path(os.path.join(src_dir, 'man-openmpi', 'man3')).resolve()
-    for file in os.listdir(man3_dir):
-        # Only want MPI man pages
-        if not prog.match(file):
-            continue
-
-        with open(os.path.join(man3_dir, file)) as fp:
-            lines = fp.readlines()
-
-        file_api_name = file.replace('.3.rst', '').lower()
-
-        # Make an initial/empty list for every MPI API man page that
-        # we find
-        directives[file_api_name] = list()
-
-        prefix = '.. mpi-bindings:'
-        for line in lines:
-            line = line.strip()
-            if not line.startswith(prefix):
-                continue
-
-            bindings = line[len(prefix):].split(',')
-            for binding in bindings:
-                binding = binding.strip()
-                directives[file_api_name].append(binding.lower())
-
-    return directives
-
-#----------------
-
 def main():
     args = setup_cli()
 
@@ -245,26 +199,12 @@ def main():
 
     # Read existing srcdir/man-openmpi/man3/MPI_*.3.rst files and look
     # for directives to guide this generation process.
-    directives = read_rst_man_pages(src_dir)
-
-    # A bit of a hack to load the pympistandard module, which is in
-    # the Open MPI '3rd-party" tree in the source dir.
-    pympistandard_dir = Path(os.path.join(src_dir, '..', '3rd-party',
-                                          'pympistandard', 'src')).resolve()
+    directives = common.read_rst_man_pages(src_dir)
 
-    sys.path.insert(0, str(pympistandard_dir))
+    # Load the embedded pympistandard library plus the MPI Standard API
+    # JSON (docs/mpi-standard-apis.json).
     global std
-    import pympistandard as std
-
-    # This is the JSON file with all the MPI standard APIs.  This is
-    # not currently officially distributed by the MPI Forum, so it was
-    # obtained by checking out the relevant branch from
-    # https://github.com/mpi-forum/mpi-standard/ and doing a build.
-    # This will create a file named apis.json.  Copy that here to this
-    # tree.
-    mpi_standard_json = os.path.abspath(os.path.join(src_dir,
-                                                     'mpi-standard-apis.json'))
-    std.use_api_version(1, given_path=mpi_standard_json)
+    std = common.load_pympistandard(src_dir)
 
     # We need to write all of these into the build tree.  See
     # docs/Makefile.am for a fuller explaination: all RST files are
diff --git a/docs/getting-help.rst b/docs/getting-help.rst
index ca9823f8a57..04596c6826a 100644
--- a/docs/getting-help.rst
+++ b/docs/getting-help.rst
@@ -249,8 +249,6 @@ of the following additional information:
 #. If you are experiencing networking problems, include detailed
    information about your network.
 
-   .. error:: TODO Update link to IB FAQ entry.
-
    #. For RoCE- or InfiniBand-based networks, include the information
       :ref:`in this FAQ entry <faq-ib-troubleshoot-label>`.
 
diff --git a/docs/index.rst b/docs/index.rst
index 50bd1c412e4..e8526858bea 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -26,15 +26,19 @@ Documentation for Open MPI can be found in the following locations:
      - Documentation location
 
    * - v5.0.0 and later
-     - Web: https://docs.open-mpi.org/
+     - * Web: https://docs.open-mpi.org/
 
-       Included in tarball: ``docs/html/index.html``
+       * Included in tarball: ``docs/html/index.html``
 
-       Built in source tree (if Sphinx available): ``docs/_build/html/index.html``
+       * Built in source tree (if Sphinx available): ``docs/_build/html/index.html``
 
-       Installed: ``$docdir/html/index.html``
+       * Installed: ``$docdir/html/index.html``
+         (which defaults to: ``$prefix/share/doc/openmpi/html/index.html``)
 
-       (which defaults to: ``$prefix/share/doc/openmpi/html/index.html``)
+       * Machine-readable, LLM-friendly artifacts for the MPI APIs (a
+         Markdown API corpus, a JSONL API catalog, curated examples, and an
+         interface guide) for this documentation version:
+         `llms.txt <llms.txt>`_
 
    * - v4.1.x and earlier
      - See the `legacy Open MPI FAQ <https://www.open-mpi.org/faq/>`_
@@ -42,7 +46,8 @@ Documentation for Open MPI can be found in the following locations:
 
        For example:
 
-       * `v4.1.x README file <https://github.com/open-mpi/ompi/blob/v4.1.x/README>`_
+       * `v4.1.x README file <https://github.com/open-mpi/ompi/blob/v4.1.x/README>`_,
+         `v4.1.x FAQ <https://www.open-mpi.org/faq/>`_
        * `v4.0.x README file <https://github.com/open-mpi/ompi/blob/v4.0.x/README>`_
 
 Release announcements
@@ -78,6 +83,7 @@ Table of contents
    app-debug/index
    developers/index
    contributing
+   code-of-conduct
    license/index
    history
    man-openmpi/index
diff --git a/docs/installing-open-mpi/configure-cli-options/index.rst b/docs/installing-open-mpi/configure-cli-options/index.rst
index e80812e4799..90c974f2909 100644
--- a/docs/installing-open-mpi/configure-cli-options/index.rst
+++ b/docs/installing-open-mpi/configure-cli-options/index.rst
@@ -11,6 +11,7 @@ below.
 .. toctree::
    :maxdepth: 1
 
+   what-to-install
    conventions
    installation
    networking
diff --git a/docs/installing-open-mpi/configure-cli-options/installation.rst b/docs/installing-open-mpi/configure-cli-options/installation.rst
index c23877adb6b..69bd05186d4 100644
--- a/docs/installing-open-mpi/configure-cli-options/installation.rst
+++ b/docs/installing-open-mpi/configure-cli-options/installation.rst
@@ -147,7 +147,7 @@ be used with ``configure``:
             <label-customizing-wrapper-compiler>` to build Open
             MPI/OpenSHMEM applications.
 
-.. _building-ompi-cli-options-diable-dlopen-label:
+.. _building-ompi-cli-options-disable-dlopen-label:
 
 * ``--enable-dlopen``: Enable Open MPI to load components as
   standalone Dynamic Shared Objects (DSOs) at run-time.  This option
diff --git a/docs/installing-open-mpi/configure-cli-options/mpi.rst b/docs/installing-open-mpi/configure-cli-options/mpi.rst
index dcc35670e72..8db0baf593d 100644
--- a/docs/installing-open-mpi/configure-cli-options/mpi.rst
+++ b/docs/installing-open-mpi/configure-cli-options/mpi.rst
@@ -29,19 +29,6 @@ MPI API behaviors that can be used with ``configure``:
 
   :ref:`See the ULFM section <ulfm-label>` for more information.
 
-* ``--enable-mpi-java``:
-  Enable building of an **EXPERIMENTAL** Java MPI interface (disabled
-  by default).  You may also need to specify ``--with-jdk-dir``,
-  ``--with-jdk-bindir``, and/or ``--with-jdk-headers``.
-
-  .. warning:: Note that this Java interface is **INCOMPLETE**
-     (meaning: it does not support all MPI functionality) and **LIKELY
-     TO CHANGE**.  The Open MPI developers would very much like to
-     hear your feedback about this interface.
-
-  :ref:`See the Java section <open-mpi-java-label>` for many more
-  details.
-
 * ``--enable-mpi-fortran[=VALUE]``:
   By default, Open MPI will attempt to build all 3 Fortran bindings:
   ``mpif.h``, the ``mpi`` module, and the ``mpi_f08`` module.  The following
@@ -67,7 +54,7 @@ MPI API behaviors that can be used with ``configure``:
 
 * ``--enable-mpi-ext[=LIST]``:
   Enable Open MPI's non-portable API extensions.  ``LIST`` is a
-  comma-delmited list of extensions.  If no ``LIST`` is specified, all
+  comma-delimited list of extensions.  If no ``LIST`` is specified, all
   of the extensions are enabled.
 
   See the "Open MPI API Extensions" section for more details.
diff --git a/docs/installing-open-mpi/configure-cli-options/networking.rst b/docs/installing-open-mpi/configure-cli-options/networking.rst
index d5ff8108929..7cc5842a4f9 100644
--- a/docs/installing-open-mpi/configure-cli-options/networking.rst
+++ b/docs/installing-open-mpi/configure-cli-options/networking.rst
@@ -32,7 +32,7 @@ can be used with ``configure``:
   compiler/linker search paths.
 
   Libfabric is the support library for OpenFabrics Interfaces-based
-  network adapters, such as Cisco usNIC, Intel True Scale PSM, etc.
+  network adapters, such as Cisco usNIC, etc.
 
 * ``--with-libfabric-libdir=DIR``:
   Look in directory for the libfabric libraries.  By default, Open MPI
@@ -58,27 +58,13 @@ can be used with ``configure``:
   ``--with-portals4-max-va-size=SIZE``:
   Set configuration values for Portals 4
 
-* ``--with-psm=<directory>``:
-  Specify the directory where the QLogic InfiniPath / Intel True Scale
-  PSM library and header files are located.  This option is generally
-  only necessary if the PSM headers and libraries are not in default
-  compiler/linker search paths.
-
-  PSM is the support library for QLogic InfiniPath and Intel True Scale
-  network adapters.
-
-* ``--with-psm-libdir=DIR``:
-  Look in directory for the PSM libraries.  By default, Open MPI will
-  look in ``DIR/lib`` and ``DIR/lib64``, which covers most cases.  This
-  option is only needed for special configurations.
-
 * ``--with-psm2=DIR``:
-  Specify the directory where the Intel Omni-Path PSM2 library and
+  Specify the directory where the Cornelis Networks Omni-Path PSM2 library and
   header files are located.  This option is generally only necessary
   if the PSM2 headers and libraries are not in default compiler/linker
   search paths.
 
-  PSM is the support library for Intel Omni-Path network adapters.
+  PSM2 is the support library for Cornelis Networks Omni-Path network adapters.
 
 * ``--with-psm2-libdir=DIR``:
   Look in directory for the PSM2 libraries.  By default, Open MPI will
diff --git a/docs/installing-open-mpi/configure-cli-options/what-to-install.rst b/docs/installing-open-mpi/configure-cli-options/what-to-install.rst
new file mode 100644
index 00000000000..2e6f3563094
--- /dev/null
+++ b/docs/installing-open-mpi/configure-cli-options/what-to-install.rst
@@ -0,0 +1,68 @@
+Deciding what to install
+========================
+
+Open MPI's ``configure`` script will, by default, search for support
+and build every component that it can.  This is convenient, and
+helpful for a good out-of-the-box experience for many HPC
+environments.
+
+However, HPC clusters rarely change from day-to-day, and large
+clusters rarely change at all.  If you know your cluster's
+configuration, there are several steps you can take to reduce the
+Open MPI installation footprint and component selection overhead.
+These steps use a combination of build-time configuration options to
+eliminate components |mdash| thus eliminating their libraries and
+avoiding unnecessary component open/close operations |mdash| as well
+as run-time MCA parameters to specify what modules to use by default
+for most users.
+
+.. caution:: This is somewhat advanced functionality, and is only
+             recommended for users who are deeply familiar with what
+             components are actually used by Open MPI in their
+             environments.
+
+             Most users should just allow building whatever components
+             Open MPI's ``configure`` script finds.
+
+Build/install-time choices
+--------------------------
+
+One way to save memory is to avoid building components that will
+actually never be selected by the system.  Unless MCA parameters
+specify which components to open, installed components are *always*
+opened and tested as to whether or not they should be selected for
+use. If you know that a component can build on your system, but due to
+your cluster's configuration will never actually be selected, then it
+is best to simply configure Open MPI to not build that component by
+using the ``--enable-mca-no-build`` CLI option to ``configure``.
+
+For example, if you know that your system will only utilize the
+``ob1`` component of the PML framework, then you can "no build" all
+the others:
+
+.. code:: sh
+
+   # See what directories (i.e., components) exist in the PML
+   # framework
+   shell$ ls -1 ompi/mca/pml
+
+   # Do not list "base", but list all other undesired components
+   # (i.e., directories).  For example, in Open MPI v6.0.0, to build
+   # *only* the OB1 PML:
+   shell$ ./configure --enable-mca-no-build=pml-cm,pml-monitoring,pml-ubcl,pml-ucx,pml-v
+
+
+This not only reduces the size of the Open MPI libraries, but can also
+avoid unnecessary component open/selection work at run time.
+
+Run-time choices
+----------------
+
+The ``$sysconfdir/openmpi-mca-params.conf`` file in the installation
+tree (which defaults to ``$prefix/etc/openmpi-mca-params.conf``) is
+where a system administrator can set system-wide defaults for Open MPI
+:ref:`run-time MCA parameters <label-running-setting-mca-param-values>`.
+
+These values can still be overridden by end users, but the values in
+this file allow the hiding of any system-specific defaults that an
+administrator may want the majority of users to utilize.
diff --git a/docs/installing-open-mpi/installation-location.rst b/docs/installing-open-mpi/installation-location.rst
index ee90b5bb432..528a1fa713b 100644
--- a/docs/installing-open-mpi/installation-location.rst
+++ b/docs/installing-open-mpi/installation-location.rst
@@ -322,14 +322,14 @@ the end):
 
         #. The C constants ``MPI_F_STATUS_IGNORE`` and ``MPI_F_STATUSES_IGNORE``
              will only compare properly to Fortran applications that were
-             created with Fortran compilers that that use the same
+             created with Fortran compilers that use the same
              name-mangling scheme as the Fortran compiler with which Open MPI was
              configured.
 
         #. Fortran compilers may have different values for the logical
              ``.TRUE.`` constant.  As such, any MPI function that uses the
              Fortran ``LOGICAL`` type may only get ``.TRUE.`` values back that
-             correspond to the the ``.TRUE.`` value of the Fortran compiler with which
+             correspond to the ``.TRUE.`` value of the Fortran compiler with which
              Open MPI was configured.
 
     #. Similar to C++, linking object files that Fortran language features such
diff --git a/docs/installing-open-mpi/packagers.rst b/docs/installing-open-mpi/packagers.rst
index c0fb13ea23a..d0ad8e9defe 100644
--- a/docs/installing-open-mpi/packagers.rst
+++ b/docs/installing-open-mpi/packagers.rst
@@ -25,7 +25,7 @@ the following:
    # Install Sphinx so that Open MPI can re-build its docs with the
    # installed PRRTE's docs
 
-   virtualalenv venv
+   virtualenv venv
    . ./venv/bin/activate
    pip install docs/requirements.txt
 
@@ -145,7 +145,7 @@ performance savings.
 .. note:: If not using a networked filesystem, or if not launching at
           scale, loading a large number of DSO files may not consume a
           noticeable amount of time during MPI process launch.  Put
-          simply: loading DSOs as indvidual files generally only
+          simply: loading DSOs as individual files generally only
           matters when using a networked filesystem while launching at
           scale.
 
diff --git a/docs/installing-open-mpi/quickstart.rst b/docs/installing-open-mpi/quickstart.rst
index 3ecc172e826..412f78593e5 100644
--- a/docs/installing-open-mpi/quickstart.rst
+++ b/docs/installing-open-mpi/quickstart.rst
@@ -37,9 +37,11 @@ packages:
 .. code-block:: sh
 
    # For Homebrew
-   shell$ brew install openmpi
+   # https://formulae.brew.sh/formula/open-mpi
+   shell$ brew install open-mpi
 
    # For MacPorts
+   # https://ports.macports.org/search/?q=openmpi
    shell$ port install openmpi
 
 .. important:: Binary packages may or may not include support for
diff --git a/docs/installing-open-mpi/required-support-libraries.rst b/docs/installing-open-mpi/required-support-libraries.rst
index 983608a3fb9..2e8944bc51f 100644
--- a/docs/installing-open-mpi/required-support-libraries.rst
+++ b/docs/installing-open-mpi/required-support-libraries.rst
@@ -29,7 +29,7 @@ system.
               compared to later versions.
 
               Other than the Hwloc restriction about v3.0.0 and beyond
-              (see below), the Open MPI community generally recomends
+              (see below), the Open MPI community generally recommends
               using the latest available version of Hwloc unless there
               is a specific reason not to.
 
@@ -88,7 +88,7 @@ system.
               may still have bugs and/or have less functionality as
               compared to later versions.
 
-              The Open MPI community generally recomends using the
+              The Open MPI community generally recommends using the
               latest available version of OpenPMIx unless there is a
               specific reason not to.
 
@@ -114,7 +114,7 @@ system.
               and run with |prte_min_version|, you will not get a
               fully-populated ``mpirun(1)`` man page.
 
-              The Open MPI community generally recomends using the
+              The Open MPI community generally recommends using the
               latest available version of PRRTE unless there is a
               specific reason not to.
 
@@ -277,7 +277,7 @@ Build example 1
 
    * If ``configure`` is unable to find header files and libraries for
      PMIx, Hwloc, and Libevent elsewhere on the build machine (i.e.,
-     assumedly the same PMIx, Hwloc, and Libevent than the PRRTE in
+     presumably the same PMIx, Hwloc, and Libevent as the PRRTE in
      ``/usr/local`` is using), this is an error: ``configure`` will
      abort, and therefore refuse to build Open MPI.
 
@@ -298,7 +298,7 @@ will cause the following to occur:
 
    * If ``configure`` is unable to find header files and libraries for
      Hwloc and Libevent elsewhere on the build machine (i.e.,
-     assumedly the same Hwloc and Libevent than the PMIx in
+     presumably the same Hwloc and Libevent as the PMIx in
      ``/opt/local`` is using), this is an error: ``configure`` will
      abort, and therefore refuse to build Open MPI.
 
diff --git a/docs/installing-open-mpi/supported-systems.rst b/docs/installing-open-mpi/supported-systems.rst
index 45b4ecd821b..76b6ef39930 100644
--- a/docs/installing-open-mpi/supported-systems.rst
+++ b/docs/installing-open-mpi/supported-systems.rst
@@ -14,7 +14,7 @@ operating systems supported has changed over time (e.g., native
 Microsoft Windows support was added in v1.3.3, and although it was
 removed prior to v1.8, is still supported through Cygwin).  :ref:`See
 the Platform Notes section <platform-notes-section-label>` for a
-listing of the OSes that that version supports.
+listing of the OSes that version supports.
 
 Open MPI is fairly POSIX-neutral, so it will run without *too* many
 modifications on most POSIX-like systems.  Hence, if we haven't listed
diff --git a/docs/launching-apps/gridengine.rst b/docs/launching-apps/gridengine.rst
index 0fed2ea191b..cd684aa6f90 100644
--- a/docs/launching-apps/gridengine.rst
+++ b/docs/launching-apps/gridengine.rst
@@ -1,13 +1,13 @@
 Launching with Grid Engine
 ==========================
 
-Open MPI supports the family of run-time schedulers including the Sun
-Grid Engine (SGE), Oracle Grid Engine (OGE), Grid Engine (GE), Son of
-Grid Engine, and others.
+Open MPI supports the Grid Engine family of run-time schedulers.  This
+family traces back to Sun Grid Engine (SGE) and includes its many
+descendants |mdash| among them Oracle Grid Engine, Son of Grid Engine,
+Univa Grid Engine (now Altair Grid Engine), and Open Cluster Scheduler.
 
-This documentation will collectively refer to all of them as "Grid
-Engine", unless a referring to a specific flavor of the Grid Engine
-family.
+This documentation collectively refers to all of them as "Grid Engine",
+unless referring to a specific member of the family.
 
 Verify Grid Engine support
 --------------------------
@@ -52,11 +52,11 @@ that were allocated by Grid Engine:
 
    # Get the environment variables for Grid Engine
 
-   # (Assuming Grid Engine is installed at /opt/sge and $Grid
-   # Engine_CELL is 'default' in your environment)
+   # (Assuming Grid Engine is installed at /opt/sge and $SGE_CELL
+   # is 'default' in your environment)
    shell$ . /opt/sge/default/common/settings.sh
 
-   # Allocate an Grid Engine interactive job with 4 slots from a
+   # Allocate a Grid Engine interactive job with 4 slots from a
    # parallel environment (PE) named 'ompi' and run a 4-process Open
    # MPI job
    shell$ qrsh -pe ompi 4 -b y mpirun -n 4 mpi-hello-world
@@ -130,18 +130,11 @@ that is used to send parallel tasks to the remote Grid Engine
 execution hosts. It will show whether the connections to the remote
 hosts are established successfully or not.
 
-.. error:: TODO is this site still live?  Doesn't look like it..  Jeff
-   emailed Dave Love on 31 Dec 2021 to ask if this is still the
-   correct URL.
-
-   Update March 2022: it doesn't look like this web site is good any
-   more.  Perhaps use https://github.com/grisu48/gridengine instead...?
-
-Various Grid Engine documentation with pointers to more is available
-at `the Son of GridEngine site <http://arc.liv.ac.uk/sge/>`_, and
-configuration instructions can be found at `the Son of GridEngine
-configuration how-to site
-<http://arc.liv.ac.uk/SGE/howto/sge-configs.html>`_.
+For more information about Grid Engine, see the actively-maintained
+open-source `Open Cluster Scheduler
+<https://github.com/hpc-gridware/clusterscheduler>`_ project |mdash|
+the current successor to Sun Grid Engine, Univa Grid Engine, and Son of
+Grid Engine |mdash| and its documentation.
 
 Grid Engine tight integration support of the ``qsub -notify`` flag
 ------------------------------------------------------------------
@@ -177,9 +170,7 @@ like this batch script can be used:
    #$ -pe ompi 16
    #$ -j y
    #$ -l h_rt=00:20:00
-   mpirun -n 16 -mca orte_forward_job_control 1 mpi-hello-world
-
-.. error:: Ralph: Does ``orte_forward_job_control`` still exist?
+   mpirun -n 16 mpi-hello-world
 
 However, one has to make one of two changes to this script for things
 to work properly.  By default, a SIGUSR1 signal will kill a shell
@@ -196,7 +187,7 @@ to handle it:
    #$ -pe ompi 16
    #$ -j y
    #$ -l h_rt=00:20:00
-   exec mpirun -n 16 -mca orte_forward_job_control 1 mpi-hello-world
+   exec mpirun -n 16 mpi-hello-world
 
 Alternatively, one can catch the signals in the script instead of doing
 an exec on the mpirun:
@@ -225,7 +216,7 @@ an exec on the mpirun:
    trap sigusr1handler SIGUSR1
    trap sigusr2handler SIGUSR2
 
-   mpirun -n 16 -mca orte_forward_job_control 1 mpi-hello-world
+   mpirun -n 16 mpi-hello-world
 
 Grid Engine job suspend / resume support
 ----------------------------------------
@@ -236,16 +227,14 @@ To suspend the job, you send a SIGTSTP (not SIGSTOP) signal to
 a SIGCONT signal to :ref:`mpirun(1) <man1-mpirun>` which will be caught and forwarded to
 the ``mpi-hello-world``.
 
-By default, this feature is not enabled.  This means that both the
-SIGTSTP and SIGCONT signals will simply be consumed by the :ref:`mpirun(1) <man1-mpirun>`
-process.  To have them forwarded, you have to run the job with ``--mca
-orte_forward_job_control 1``.  Here is an example on Solaris:
-
-.. error:: TODO Ralph: does ``orte_forward_job_control`` still exist?
+By default, ``mpirun`` forwards the SIGTSTP and SIGCONT signals to the
+application processes (delivering SIGTSTP as SIGSTOP so the processes
+suspend), so no special option is required to enable this behavior.
+Here is an example on Solaris:
 
 .. code-block:: sh
 
-   shell$ mpirun -mca orte_forward_job_control 1 -n 2 mpi-hello-world
+   shell$ mpirun -n 2 mpi-hello-world
 
 In another window, we suspend and continue the job:
 
diff --git a/docs/launching-apps/lsf.rst b/docs/launching-apps/lsf.rst
index 159a85a84a4..988a1a02582 100644
--- a/docs/launching-apps/lsf.rst
+++ b/docs/launching-apps/lsf.rst
@@ -1,7 +1,12 @@
 Launching with LSF
 ==================
 
-Open MPI supports the LSF resource manager.
+Open MPI supports some versions of the LSF resource manager.
+
+Problems have been reported with using the most recent releases of LSF, in particular
+the version supplied with IBM Spectrum LSF Version 10.1 Fix Pack 15.
+The suggested workaround is to use an older release of the LSF 10.1 package or to
+configure Open MPI without LSF support.
 
 Verify LSF support
 ------------------
diff --git a/docs/launching-apps/pmix-and-prrte.rst b/docs/launching-apps/pmix-and-prrte.rst
index 11183f57925..61dcb96766b 100644
--- a/docs/launching-apps/pmix-and-prrte.rst
+++ b/docs/launching-apps/pmix-and-prrte.rst
@@ -28,7 +28,7 @@ abstractions and configuration options belong to Open MPI vs. PMIx
 vs. PRRTE.
 
 Advanced users can peek into the PMIx and PRRTE internals and tweak
-additional configuration settings if necessary, but we hope that that
+additional configuration settings if necessary, but we hope that
 will rarely be necessary.
 
 PMIx
@@ -48,7 +48,7 @@ PMIx presents a unified API that hides many of the complexities of
 communication with these back-end run-time environments.  Open MPI
 uses the PMIx API to discover, communicate, and coordinate with any
 supported back-end run-time system without needing to know the
-intimiate details of that system.
+intimate details of that system.
 
 PRRTE
 -----
diff --git a/docs/launching-apps/prerequisites.rst b/docs/launching-apps/prerequisites.rst
index 036ba915a64..3ad824cbbff 100644
--- a/docs/launching-apps/prerequisites.rst
+++ b/docs/launching-apps/prerequisites.rst
@@ -66,7 +66,7 @@ For example:
 
 Additionally, Open MPI requires that jobs can be started on remote
 nodes without any input from the keyboard.  For example, if using
-``ssh`` as the remote agent, you must have your environment setup to
+``ssh`` as the remote agent, you must have your environment set up to
 allow execution on remote nodes without entering a password or
 passphrase.
 
@@ -249,8 +249,3 @@ uses ``--prefix``:
 .. code-block::
 
    shell$ /opt/openmpi-VERSION/bin/mpirun -n 4 a.out
-
-.. error:: TODO Josh H points out that we might also want to mention
-           ``OMPIHOME`` for PRRTE's ``.ini`` file here.  Leaving this
-           as a future to-do item, since PRRTE's ``.ini`` file support
-           does not exist yet.
diff --git a/docs/launching-apps/ssh.rst b/docs/launching-apps/ssh.rst
index 39bd04a2732..3251bfd9f74 100644
--- a/docs/launching-apps/ssh.rst
+++ b/docs/launching-apps/ssh.rst
@@ -50,7 +50,7 @@ There are three mechanisms for specifying the hosts that an MPI job will run on:
 Non-interactive ``ssh`` logins
 ------------------------------
 
-SSH keys must be setup such that the following can be executed without
+SSH keys must be set up such that the following can be executed without
 being prompted for password or passphrase:
 
 .. code-block:: sh
@@ -60,7 +60,7 @@ being prompted for password or passphrase:
    shell$
 
 Consult instructions and tutorials from around the internet to learn
-how to setup SSH keys.  Try Google search terms like "passwordless
+how to set up SSH keys.  Try Google search terms like "passwordless
 SSH" or "SSH key authentication".
 
 For simplicity, it may be desirable to configure your SSH keys
@@ -75,12 +75,12 @@ comfortable with.
    or passphrase |mdash| *to any node* in the host list *from any
    node* in the host list.
 
-   It may *not* be sufficient to only setup an SSH key from the node
+   It may *not* be sufficient to only set up an SSH key from the node
    where you are invoking :ref:`mpirun(1) <man1-mpirun>` to all other
    nodes.
 
 If you have a shared ``$HOME`` filesystem between your nodes, you can
-setup a single SSH key that is used to login to all nodes.
+set up a single SSH key that is used to login to all nodes.
 
 Finding Open MPI executables and libraries
 ------------------------------------------
diff --git a/docs/launching-apps/troubleshooting.rst b/docs/launching-apps/troubleshooting.rst
index e5ed1618a48..029bcef575b 100644
--- a/docs/launching-apps/troubleshooting.rst
+++ b/docs/launching-apps/troubleshooting.rst
@@ -61,9 +61,11 @@ why this can happen.
     linker is smart enough to not load ``libmpi`` twice |mdash| but it
     does keeps ``libmpi`` in a public scope.
   * Use the ``--disable-dlopen`` or ``--disable-mca-dso`` options to
-    Open MPI's ``configure`` script (see this TODO NONEXISTENT FAQ entry
-    for more details on these
-    options).  These options slurp all of Open MPI's plugins up in to
+    Open MPI's ``configure`` script (see the
+    :ref:`--disable-dlopen <building-ompi-cli-options-disable-dlopen-label>`
+    and :ref:`--enable-mca-dso / --enable-mca-static
+    <building-ompi-cli-options-mca-dso-label>` option descriptions for
+    more details).  These options slurp all of Open MPI's plugins up in to
     ``libmpi`` |mdash| meaning that the plugins physically reside in
     ``libmpi`` and will not be dynamically opened at run time.
   * Build Open MPI as a static library by configuring Open MPI with
@@ -77,7 +79,7 @@ Errors about missing libraries
 When building Open MPI with the compilers that have libraries in
 non-default search path locations, you may see errors about those
 compiler's support libraries when trying to launch MPI applications if
-their corresponding environments were not setup properly.
+their corresponding environments were not set up properly.
 
 For example, you may see warnings similar to the following:
 
@@ -107,13 +109,13 @@ Specifically, Open MPI first attempts to launch a "helper" daemon
 libraries shown above (``libimf.so``, ``libpgcc.so``, and
 ``libmv.so``) are specific to their compiler suites (Intel, PGI, and
 PathScale, respectively).  As such, it is likely that the user did not
-setup the compiler library in their environment properly on this node.
+set up the compiler library in their environment properly on this node.
 
-Double check that you have setup the appropriate compiler environment
+Double check that you have set up the appropriate compiler environment
 on the target node, for both interactive and non-interactive logins.
 
 .. note:: It is a common error to ensure that the compiler environment
-          is setup properly for *interactive* logins, but not for
+          is set up properly for *interactive* logins, but not for
           *non-interactive* logins.
 
 Here's an example of a user-compiled MPI application working fine
@@ -142,7 +144,7 @@ locally, but failing when invoked non-interactively on a remote node:
    mpi_hello: error while loading shared libraries: libimf.so: cannot open shared object file: No such file or directory
 
 In cases like this, check your shell script startup files and verify
-that the appropriate compiler environment is setup properly for
+that the appropriate compiler environment is set up properly for
 non-interactive logins.
 
 Problems when running across multiple hosts
@@ -162,7 +164,7 @@ them across multiple hosts, try the following:
       remotehost
 
    If you are unable to launch across multiple hosts, check that your
-   SSH keys are setup properly.  Or, if you are running in a managed
+   SSH keys are set up properly.  Or, if you are running in a managed
    environment, such as in a Slurm, Torque, or other job launcher,
    check that you have reserved enough hosts, are running in an
    allocated job, etc.
diff --git a/docs/llms-src/openmpi-docs-manifest.schema.json b/docs/llms-src/openmpi-docs-manifest.schema.json
new file mode 100644
index 00000000000..366961be0c9
--- /dev/null
+++ b/docs/llms-src/openmpi-docs-manifest.schema.json
@@ -0,0 +1,100 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://docs.open-mpi.org/llms/openmpi-docs-manifest.schema.json",
+  "title": "Open MPI LLM-friendly documentation manifest",
+  "description": "Schema for openmpi-docs-manifest.json. The manifest is the single artifact that carries build identity, and it does not inventory itself. See specs/llms-friendly-docs/spec.md.",
+  "type": "object",
+  "additionalProperties": true,
+  "required": [
+    "artifact_schema_version",
+    "project",
+    "ompi_version",
+    "generated_at",
+    "artifacts"
+  ],
+  "properties": {
+    "artifact_schema_version": {
+      "type": "integer",
+      "const": 1,
+      "description": "Version of the manifest schema."
+    },
+    "project": {
+      "type": "string",
+      "const": "open-mpi"
+    },
+    "ompi_version": {
+      "type": "string",
+      "description": "Open MPI version derived from the top-level VERSION file."
+    },
+    "ompi_series": {
+      "type": ["string", "null"],
+      "description": "Open MPI documentation series, e.g. v6.1.x."
+    },
+    "rtd_version_slug": {
+      "type": ["string", "null"],
+      "description": "Read the Docs version slug when available."
+    },
+    "git_commit": {
+      "type": ["string", "null"],
+      "description": "Source commit used for the documentation build, when available."
+    },
+    "git_describe": {
+      "type": ["string", "null"],
+      "description": "git describe --tags --always output, when available."
+    },
+    "generated_at": {
+      "type": "string",
+      "description": "UTC generation timestamp (ISO 8601). Always present: derived from SOURCE_DATE_EPOCH when set, else the build commit date, else the tarball/build date."
+    },
+    "artifacts": {
+      "type": "array",
+      "description": "One entry per generated and curated artifact, EXCEPT the manifest itself.",
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+        "required": ["path", "media_type", "sha256", "bytes"],
+        "properties": {
+          "path": {
+            "type": "string",
+            "description": "Path relative to the published version root, e.g. llms/openmpi-mpi-api.jsonl."
+          },
+          "url": {
+            "type": ["string", "null"],
+            "description": "Absolute published URL, when the URL base is known."
+          },
+          "media_type": {
+            "type": "string",
+            "description": "Media type, e.g. application/jsonl, text/markdown, application/json."
+          },
+          "sha256": {
+            "type": "string",
+            "pattern": "^[0-9a-f]{64}$",
+            "description": "SHA-256 of the artifact bytes (artifacts are wall-clock-free, so this is stable at a commit)."
+          },
+          "bytes": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "tokens_estimate": {
+            "type": ["integer", "null"],
+            "minimum": 0,
+            "description": "Estimated token count for the artifact."
+          },
+          "symbols": {
+            "type": ["array", "null"],
+            "items": { "type": "string" },
+            "description": "Symbol names covered by the artifact, when applicable."
+          },
+          "languages": {
+            "type": ["array", "null"],
+            "items": {
+              "type": "string",
+              "enum": ["c", "fortran_mpifh", "fortran_use_mpi", "fortran_mpi_f08"]
+            },
+            "description": "Language/interface set covered by the artifact, when applicable."
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/docs/llms-src/openmpi-mpi-api.schema.json b/docs/llms-src/openmpi-mpi-api.schema.json
new file mode 100644
index 00000000000..05e6ef00c41
--- /dev/null
+++ b/docs/llms-src/openmpi-mpi-api.schema.json
@@ -0,0 +1,240 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://docs.open-mpi.org/llms/openmpi-mpi-api.schema.json",
+  "title": "Open MPI LLM-friendly API catalog record",
+  "description": "Schema for one JSON object (one line) in openmpi-mpi-api.jsonl. Schema version 1. See specs/llms-friendly-docs/spec.md.",
+  "type": "object",
+  "additionalProperties": true,
+  "required": [
+    "schema_version",
+    "project",
+    "docset",
+    "name",
+    "kind",
+    "standard",
+    "category",
+    "languages",
+    "bindings",
+    "parameters",
+    "semantics",
+    "errors",
+    "seealso",
+    "urls",
+    "sources"
+  ],
+  "properties": {
+    "schema_version": {
+      "type": "integer",
+      "const": 1,
+      "description": "Version of this JSONL record schema, independent of the Open MPI release."
+    },
+    "project": {
+      "type": "string",
+      "const": "open-mpi"
+    },
+    "docset": {
+      "type": "object",
+      "additionalProperties": true,
+      "description": "Semantic-only build descriptor. Build identity (git/timestamp) lives only in the manifest.",
+      "required": ["ompi_version", "schema_version"],
+      "properties": {
+        "ompi_version": {
+          "type": "string",
+          "description": "Open MPI version derived from the top-level VERSION file, e.g. v6.1.0a1."
+        },
+        "ompi_series": {
+          "type": "string",
+          "description": "Open MPI documentation series, e.g. v6.1.x."
+        },
+        "schema_version": {
+          "type": "integer",
+          "const": 1
+        }
+      }
+    },
+    "name": {
+      "type": "string",
+      "description": "Primary API name, e.g. MPI_Send.",
+      "minLength": 1
+    },
+    "kind": {
+      "type": "string",
+      "enum": ["standard", "extension", "deprecated", "removed"]
+    },
+    "standard": {
+      "type": ["object", "null"],
+      "description": "MPI Standard version information when known.",
+      "additionalProperties": true,
+      "properties": {
+        "version": {
+          "type": ["string", "null"],
+          "description": "MPI Standard version string, e.g. 4.1, when known."
+        }
+      }
+    },
+    "category": {
+      "type": ["string", "null"],
+      "enum": [
+        "point-to-point",
+        "collective",
+        "communicator",
+        "group",
+        "datatype",
+        "rma",
+        "io",
+        "topology",
+        "sessions",
+        "info",
+        "process",
+        "error-handling",
+        "tools",
+        "extension",
+        "other",
+        null
+      ]
+    },
+    "languages": {
+      "type": "array",
+      "description": "The set of language interfaces for which this record provides bindings; should match the distinct `language` values across `bindings`. JSON Schema validates only enum membership and uniqueness here; the cross-field equality with `bindings[].language` is enforced separately by the CI validator.",
+      "items": {
+        "type": "string",
+        "enum": ["c", "fortran_mpifh", "fortran_use_mpi", "fortran_mpi_f08"]
+      },
+      "uniqueItems": true
+    },
+    "bindings": {
+      "type": "array",
+      "description": "One entry per binding variant. May be empty for an extension with no recoverable signature.",
+      "items": {
+        "type": "object",
+        "additionalProperties": true,
+        "required": ["language", "procedure", "signature", "large_count", "return_convention", "parameters"],
+        "properties": {
+          "language": {
+            "type": "string",
+            "enum": ["c", "fortran_mpifh", "fortran_use_mpi", "fortran_mpi_f08"]
+          },
+          "procedure": {
+            "type": "string",
+            "description": "Procedure name for this binding, e.g. MPI_Send."
+          },
+          "signature": {
+            "type": "string",
+            "description": "Rendered signature text."
+          },
+          "large_count": {
+            "type": "boolean",
+            "description": "True if this is the large-count ('embiggened', _c) variant."
+          },
+          "return_convention": {
+            "type": ["string", "null"],
+            "description": "How the binding reports errors/results, e.g. 'int return code' (C) or 'ierror argument' (Fortran)."
+          },
+          "parameters": {
+            "type": "array",
+            "items": { "$ref": "#/$defs/parameter" }
+          }
+        }
+      }
+    },
+    "parameters": {
+      "type": "array",
+      "description": "Normalized parameter metadata. For extension records, fields may be 'unknown' or omitted.",
+      "items": { "$ref": "#/$defs/parameter" }
+    },
+    "semantics": {
+      "type": ["object", "null"],
+      "additionalProperties": true,
+      "properties": {
+        "blocking": { "type": ["boolean", "string", "null"] },
+        "collective": { "type": ["boolean", "string", "null"] },
+        "local": { "type": ["boolean", "string", "null"] },
+        "initialization_required": { "type": ["boolean", "string", "null"] },
+        "threading_notes": { "type": ["string", "null"] }
+      }
+    },
+    "errors": {
+      "type": ["object", "null"],
+      "additionalProperties": true,
+      "properties": {
+        "convention": {
+          "type": ["string", "null"],
+          "description": "Error-return convention summary."
+        },
+        "url": {
+          "type": ["string", "null"],
+          "description": "Link to the human error-handling documentation."
+        }
+      }
+    },
+    "seealso": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Related API names."
+    },
+    "documented_with": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Co-documented procedure names that share this API's man page."
+    },
+    "urls": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["html", "markdown"],
+      "properties": {
+        "html": {
+          "type": "string",
+          "description": "Canonical human HTML page URL for this procedure."
+        },
+        "markdown": {
+          "type": "string",
+          "description": "Per-symbol Markdown page URL for this procedure (every documented procedure has one)."
+        }
+      }
+    },
+    "sources": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["rst"],
+      "properties": {
+        "rst": {
+          "type": "string",
+          "description": "Source RST path (relative to the docs source tree) for this procedure's man page."
+        },
+        "binding_metadata": {
+          "type": ["string", "null"],
+          "description": "Origin of the binding metadata, e.g. 'pympistandard' or 'rst' for extensions."
+        }
+      }
+    }
+  },
+  "$defs": {
+    "parameter": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": ["name"],
+      "properties": {
+        "name": { "type": "string" },
+        "direction": {
+          "type": ["string", "null"],
+          "enum": ["in", "out", "inout", "unknown", null]
+        },
+        "type": {
+          "type": ["string", "null"],
+          "description": "Datatype/kind of the parameter, when known."
+        },
+        "intent": {
+          "type": ["string", "null"],
+          "description": "Fortran intent or C const-ness, when known."
+        },
+        "optional": {
+          "enum": [true, false, "unknown", null],
+          "description": "Whether the parameter is optional; the only permitted string is 'unknown' (when not reliably extractable)."
+        },
+        "description": {
+          "type": ["string", "null"]
+        }
+      }
+    }
+  }
+}
diff --git a/docs/llms-src/openmpi-mpi-examples.md b/docs/llms-src/openmpi-mpi-examples.md
new file mode 100644
index 00000000000..665a632afb8
--- /dev/null
+++ b/docs/llms-src/openmpi-mpi-examples.md
@@ -0,0 +1,323 @@
+# Open MPI examples
+
+A small, representative set of MPI examples for Open MPI. The goal is coverage
+of common patterns, not exhaustive API coverage. The MPI Standard
+(https://www.mpi-forum.org/docs/) is authoritative for portable semantics.
+
+Compile and run with Open MPI's wrapper compilers:
+
+```sh
+mpicc   -o example example.c        # C
+mpifort -o example example.f90      # Fortran
+mpirun -n 4 ./example
+```
+
+The "hello world" and "ring" programs below are the canonical Open MPI example
+programs that ship in the source tree under `examples/` (and are compiled in
+CI). The remaining C examples illustrate additional common patterns.
+
+## C: initialize and finalize (`examples/hello_c.c`)
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank, size, len;
+    char version[MPI_MAX_LIBRARY_VERSION_STRING];
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    MPI_Get_library_version(version, &len);
+    printf("Hello, world, I am %d of %d, (%s, %d)\n", rank, size, version, len);
+    MPI_Finalize();
+
+    return 0;
+}
+```
+
+## C: point-to-point send/receive (`examples/ring_c.c`)
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank, size, next, prev, message, tag = 201;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    next = (rank + 1) % size;
+    prev = (rank + size - 1) % size;
+
+    if (0 == rank) {
+        message = 10;
+        MPI_Send(&message, 1, MPI_INT, next, tag, MPI_COMM_WORLD);
+    }
+
+    while (1) {
+        MPI_Recv(&message, 1, MPI_INT, prev, tag, MPI_COMM_WORLD,
+                 MPI_STATUS_IGNORE);
+        if (0 == rank) {
+            --message;
+        }
+        MPI_Send(&message, 1, MPI_INT, next, tag, MPI_COMM_WORLD);
+        if (0 == message) {
+            break;
+        }
+    }
+
+    if (0 == rank) {
+        MPI_Recv(&message, 1, MPI_INT, prev, tag, MPI_COMM_WORLD,
+                 MPI_STATUS_IGNORE);
+    }
+
+    MPI_Finalize();
+    return 0;
+}
+```
+
+## C: collective communication (allreduce)
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank, size, local, total;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    local = rank + 1;
+    MPI_Allreduce(&local, &total, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
+    if (0 == rank) {
+        printf("Sum of ranks+1 across %d processes = %d\n", size, total);
+    }
+
+    MPI_Finalize();
+    return 0;
+}
+```
+
+## C: nonblocking communication
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank, size, send_val, recv_val, next, prev, tag = 0;
+    MPI_Request reqs[2];
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    next = (rank + 1) % size;
+    prev = (rank + size - 1) % size;
+    send_val = rank;
+
+    MPI_Irecv(&recv_val, 1, MPI_INT, prev, tag, MPI_COMM_WORLD, &reqs[0]);
+    MPI_Isend(&send_val, 1, MPI_INT, next, tag, MPI_COMM_WORLD, &reqs[1]);
+    MPI_Waitall(2, reqs, MPI_STATUSES_IGNORE);
+
+    printf("Rank %d received %d from rank %d\n", rank, recv_val, prev);
+
+    MPI_Finalize();
+    return 0;
+}
+```
+
+## C: derived datatype (contiguous)
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank, tag = 0;
+    double buf[4] = {0, 0, 0, 0};
+    MPI_Datatype vec4;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    MPI_Type_contiguous(4, MPI_DOUBLE, &vec4);
+    MPI_Type_commit(&vec4);
+
+    if (0 == rank) {
+        for (int i = 0; i < 4; i++) buf[i] = i * 1.5;
+        MPI_Send(buf, 1, vec4, 1, tag, MPI_COMM_WORLD);
+    } else if (1 == rank) {
+        MPI_Recv(buf, 1, vec4, 0, tag, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+        printf("Rank 1 received: %g %g %g %g\n", buf[0], buf[1], buf[2], buf[3]);
+    }
+
+    MPI_Type_free(&vec4);
+    MPI_Finalize();
+    return 0;
+}
+```
+
+## C: communicators (split)
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank, color, subrank;
+    MPI_Comm subcomm;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    color = rank % 2;  /* split into even/odd groups */
+    MPI_Comm_split(MPI_COMM_WORLD, color, rank, &subcomm);
+    MPI_Comm_rank(subcomm, &subrank);
+
+    printf("World rank %d -> color %d, subcomm rank %d\n", rank, color, subrank);
+
+    MPI_Comm_free(&subcomm);
+    MPI_Finalize();
+    return 0;
+}
+```
+
+## C: MPI-IO (collective write)
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank;
+    MPI_File fh;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    MPI_File_open(MPI_COMM_WORLD, "out.dat",
+                  MPI_MODE_CREATE | MPI_MODE_WRONLY, MPI_INFO_NULL, &fh);
+    MPI_File_set_view(fh, rank * (MPI_Offset) sizeof(int),
+                      MPI_INT, MPI_INT, "native", MPI_INFO_NULL);
+    MPI_File_write_all(fh, &rank, 1, MPI_INT, MPI_STATUS_IGNORE);
+    MPI_File_close(&fh);
+
+    MPI_Finalize();
+    return 0;
+}
+```
+
+## C: one-sided / RMA (window + put)
+
+```c
+#include "mpi.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    int rank, size, value, *winbuf;
+    MPI_Win win;
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+    MPI_Alloc_mem(sizeof(int), MPI_INFO_NULL, &winbuf);
+    *winbuf = 0;
+    MPI_Win_create(winbuf, sizeof(int), sizeof(int), MPI_INFO_NULL,
+                   MPI_COMM_WORLD, &win);
+
+    value = rank;
+    MPI_Win_fence(0, win);
+    /* Each rank writes its value into rank 0's window. */
+    MPI_Put(&value, 1, MPI_INT, 0, 0, 1, MPI_INT, win);
+    MPI_Win_fence(0, win);
+
+    if (0 == rank) {
+        printf("Rank 0 window holds %d after RMA\n", *winbuf);
+    }
+
+    MPI_Win_free(&win);
+    MPI_Free_mem(winbuf);
+    MPI_Finalize();
+    return 0;
+}
+```
+
+## Fortran `use mpi_f08`: initialize and finalize (`examples/hello_usempif08.f90`)
+
+```fortran
+program main
+    use mpi_f08
+    implicit none
+    integer :: rank, size, len
+    character(len=MPI_MAX_LIBRARY_VERSION_STRING) :: version
+
+    call MPI_INIT()
+    call MPI_COMM_RANK(MPI_COMM_WORLD, rank)
+    call MPI_COMM_SIZE(MPI_COMM_WORLD, size)
+    call MPI_GET_LIBRARY_VERSION(version, len)
+    write(*, '("Hello, world, I am ", i2, " of ", i2, ": ", a)') &
+          rank, size, version
+    call MPI_FINALIZE()
+end
+```
+
+## Fortran `use mpi`: initialize and finalize (`examples/hello_usempi.f90`)
+
+```fortran
+program main
+    use mpi
+    implicit none
+    integer :: rank, size, ierror
+
+    call MPI_INIT(ierror)
+    call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierror)
+    call MPI_COMM_SIZE(MPI_COMM_WORLD, size, ierror)
+    write(*, '("Hello, world, I am ", i2, " of ", i2)') rank, size
+    call MPI_FINALIZE(ierror)
+end
+```
+
+## Fortran `mpif.h`: initialize and finalize (`examples/hello_mpifh.f`)
+
+```fortran
+      program main
+      implicit none
+      include 'mpif.h'
+      integer rank, size, ierror
+
+      call MPI_INIT(ierror)
+      call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierror)
+      call MPI_COMM_SIZE(MPI_COMM_WORLD, size, ierror)
+      print *, 'Hello, world, I am ', rank, ' of ', size
+      call MPI_FINALIZE(ierror)
+      end
+```
+
+## Compiling and running
+
+```sh
+mpicc   -o hello   hello_c.c        && mpirun -n 4 ./hello
+mpicc   -o ring    ring_c.c         && mpirun -n 4 ./ring
+mpifort -o hellof  hello_usempif08.f90 && mpirun -n 4 ./hellof
+```
+
+The canonical `hello_*` and `ring_*` programs (C, `mpif.h`, `use mpi`, and
+`use mpi_f08`) live in the Open MPI source tree under `examples/` and are
+compiled in CI via `examples/Makefile`. The additional C examples above are
+documentation examples.
diff --git a/docs/llms-src/openmpi-mpi-interface-guide.md b/docs/llms-src/openmpi-mpi-interface-guide.md
new file mode 100644
index 00000000000..a9e52d98d51
--- /dev/null
+++ b/docs/llms-src/openmpi-mpi-interface-guide.md
@@ -0,0 +1,98 @@
+# Open MPI interface selection guide
+
+This guide helps tools and developers choose the correct MPI language
+interface when reading or generating Open MPI application code. The MPI
+Standard (https://www.mpi-forum.org/docs/) is authoritative for portable MPI
+semantics; this guide describes how the interfaces map onto Open MPI.
+
+## The four MPI language interfaces
+
+Open MPI provides the MPI APIs through four interfaces:
+
+| Interface | Access | Use for |
+|-----------|--------|---------|
+| C | `#include <mpi.h>` | C and C++ application code |
+| `mpif.h` | `INCLUDE 'mpif.h'` | legacy Fortran code (fixed/free form) |
+| `use mpi` | `USE mpi` | legacy Fortran code wanting a module |
+| `use mpi_f08` | `USE mpi_f08` | new Fortran code |
+
+## Choosing an interface
+
+- **C** — Choose the C interface for C or C++ code. Include `<mpi.h>`. MPI
+  handles are opaque C types (`MPI_Comm`, `MPI_Datatype`, `MPI_Request`, …)
+  and almost every routine returns an `int` error code.
+
+- **`use mpi_f08`** — **Prefer this for new Fortran code.** It is the modern,
+  type-safe Fortran 2008 interface: handles are derived types (for example
+  `TYPE(MPI_Comm)`, `TYPE(MPI_Datatype)`), procedures have explicit
+  interfaces so the compiler checks argument types, and the final `ierror`
+  argument is `OPTIONAL`.
+
+- **`mpif.h` and `use mpi`** — These are **legacy** interfaces, retained for
+  compatibility with older Fortran code. In both, MPI handles are default
+  `INTEGER`s and `ierror` is a required final argument. They expose the same
+  procedure signatures and differ only in how they are accessed
+  (`INCLUDE 'mpif.h'` versus `USE mpi`); the `use mpi` module additionally
+  provides some compile-time checking that `mpif.h` does not. Use these only
+  when extending existing code that already uses them.
+
+## Wrapper compilers
+
+Compile and link MPI applications with Open MPI's **wrapper compilers**, which
+add the correct include and library flags automatically. Do not invoke the
+underlying compiler with hand-written MPI flags.
+
+| Language | Wrapper |
+|----------|---------|
+| C | `mpicc` |
+| C++ | `mpicxx` (also `mpic++`) |
+| Fortran (all interfaces) | `mpifort` (also legacy `mpif77`/`mpif90`) |
+
+For example:
+
+```sh
+mpicc   -o hello hello.c
+mpifort -o hello hello.f90
+```
+
+## Large-count (`_c`) variants
+
+MPI-4.0 added large-count variants of routines that take element counts, so
+counts can exceed the range of a C `int`. In the C interface these have a
+`_c` suffix and take `MPI_Count`/`MPI_Aint` arguments instead of `int`:
+
+```c
+int MPI_Send  (const void *buf, int       count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm);
+int MPI_Send_c(const void *buf, MPI_Count count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm);
+```
+
+Use the `_c` variant when a count (or displacement) may exceed `INT_MAX`. In
+the `use mpi_f08` interface the same routine is overloaded for large counts
+via `INTEGER(KIND=MPI_COUNT_KIND)` arguments (no separate name). In the
+catalog (`openmpi-mpi-api.jsonl`), large-count bindings are marked with
+`"large_count": true`.
+
+## Open MPI extensions (`MPIX_*` and `OMPI_*`)
+
+Symbols prefixed with `MPIX_` or `OMPI_` are **Open MPI extensions**, not part
+of the MPI Standard, and are **not portable** to other MPI implementations.
+Examples include the ULFM fault-tolerance routines (`MPIX_Comm_*`) and
+`MPIX_Query_cuda_support`. Because the Open MPI extension header
+`<mpi-ext.h>` is itself Open MPI-specific (other MPI implementations may not
+provide it at all), simply including it and checking `OMPI_HAVE_MPI_EXT` does
+not make code portable: the include can fail to compile elsewhere before any
+macro is ever tested. To stay portable, gate the include itself on an
+implementation check (e.g. `#if defined(OPEN_MPI)`), then test the **specific**
+feature macro documented in the relevant man page (for example,
+`OMPI_HAVE_MPI_EXT_CUDA`) rather than the umbrella `OMPI_HAVE_MPI_EXT`:
+
+```c
+#if defined(OPEN_MPI)
+#  include <mpi-ext.h>
+#  if defined(OMPI_HAVE_MPI_EXT_CUDA) && OMPI_HAVE_MPI_EXT_CUDA
+     /* use MPIX_Query_cuda_support(), etc. */
+#  endif
+#endif
+```
+
+In the catalog these records have `"kind": "extension"`.
diff --git a/docs/llms-src/openmpi-runtime-introspection.md b/docs/llms-src/openmpi-runtime-introspection.md
new file mode 100644
index 00000000000..8a806d35f5a
--- /dev/null
+++ b/docs/llms-src/openmpi-runtime-introspection.md
@@ -0,0 +1,137 @@
+# Open MPI runtime introspection with `ompi_info`
+
+The rest of this corpus describes the MPI **API** — the signatures,
+parameters, and semantics that are fixed for a given Open MPI version. It
+deliberately does **not** describe any single *installation*: the exact
+version and build configuration, which optional components were compiled in,
+or the run-time tunables (MCA parameters) those components expose. All of that
+is installation-specific, so it is not snapshotted into this corpus.
+
+Instead, query the installation directly. If you (or the program you are
+assisting) can reach an Open MPI installation, the `ompi_info` command is the
+authoritative, version-correct source for everything below — far more reliable
+than guessing from this corpus, which documents the API, not the local build.
+`ompi_info` itself is documented by the `ompi_info(1)` command man page
+(indexed in this `llms.txt`).
+
+## Version and build configuration
+
+- `ompi_info --version` prints the Open MPI version, e.g. `Open MPI v6.1.0a1`.
+- `ompi_info` with no arguments prints a human-readable summary: the version,
+  the `./configure` command line, the compilers used, which language bindings
+  (C, `mpif.h`, `use mpi`, `use mpi_f08`) are enabled, and the MCA components
+  that were built.
+- `ompi_info --parsable` prints the same information as stable, machine-readable
+  `key:value` lines. Useful examples:
+
+  ```
+  ompi:version:full:6.1.0a1     # the Open MPI version
+  mpi-api:version:full:4.1.0    # the MPI standard level this build implements
+  ```
+
+## Available components
+
+Open MPI is built from MCA components (plugins) grouped into frameworks (such
+as `btl` for byte transport, `coll` for collective algorithms, and `pml` for
+point-to-point messaging). Which components are present depends on how the
+installation was configured and built, so the only reliable way to list them
+is from the installation itself, with:
+
+```
+ompi_info --all --parsable
+```
+
+Component lines are keyed `mca:<framework>:<component>:version:...`; for
+example, an `mca:btl:tcp:version:...` line shows that the TCP BTL component is
+present in this build.
+
+## Discovering MCA parameters (run-time tunables)
+
+MCA parameters control almost all run-time behavior — network selection,
+collective algorithms, buffer sizes, and much more. The available set again
+depends on which components were built, so list them from the installation
+rather than expecting them in this corpus:
+
+```
+ompi_info --all --parsable
+```
+
+`--all` raises the detail to the maximum (every parameter at every "level",
+1–9) and `--parsable` emits the machine-readable form. Plain `ompi_info` shows
+only the small set of level-1 parameters; `--all` is what makes the listing
+comprehensive.
+
+The output is **self-describing**: each parameter emits one line per field,
+keyed `mca:<framework>:<component>:param:<name>:<field>:<value>`. For example:
+
+```
+mca:btl:tcp:param:btl_tcp_if_include:value:
+mca:btl:tcp:param:btl_tcp_if_include:source:default
+mca:btl:tcp:param:btl_tcp_if_include:status:read-only
+mca:btl:tcp:param:btl_tcp_if_include:level:1
+mca:btl:tcp:param:btl_tcp_if_include:help:Comma-delimited list of devices and/or CIDR notation of networks to use for MPI communication ...
+mca:btl:tcp:param:btl_tcp_if_include:type:string
+mca:btl:tcp:param:btl_tcp_if_include:deprecated:no
+```
+
+Read the field names directly from the output rather than relying on a fixed
+list here — fields can be added over time. The fields you will typically see
+include the current `value`, where it came from (`source`), whether it can be
+changed at run time (`status`), the verbosity `level` (1–3 end user, 4–6
+application tuner, 7–9 implementer), the `help` text, the value `type`, whether
+it is `deprecated`, any `enumerator` lines (the allowed values of an enumerated
+parameter), and any `synonym_of` (an older name that still works).
+
+Narrow the query to one component with `--param <framework> <component>`
+(e.g. `ompi_info --param btl tcp --level 9`), and add `--internal` to include
+parameters intended only for Open MPI developers.
+
+## Setting MCA parameters
+
+Once you know a parameter's name, it can be set several ways. They are listed
+here highest precedence first (a command-line setting overrides an environment
+variable, which overrides a file):
+
+**1. On the `mpirun` / `mpiexec` command line** with `--mca <name> <value>`
+(highest precedence). `mpiexec` is a synonym for `mpirun`.
+
+```sh
+# Use only the TCP and shared-memory BTLs for MPI communication:
+mpirun --mca btl tcp,self,sm -np 4 ./my_app
+
+# Restrict the TCP BTL to a specific network:
+mpiexec --mca btl_tcp_if_include 192.168.1.0/24 -np 4 ./my_app
+```
+
+Quote any value that contains spaces or shell metacharacters, e.g.
+`--mca <name> "value with spaces"`.
+
+**2. In the environment**, by prefixing the parameter name with `OMPI_MCA_`.
+This has the same effect as the command line but applies to every launch in
+that environment:
+
+```sh
+export OMPI_MCA_btl=tcp,self,sm
+export OMPI_MCA_btl_tcp_if_include=192.168.1.0/24
+mpirun -np 4 ./my_app
+```
+
+**3. In MCA parameter files.** A tuning file passed with `mpirun --tune <file>`,
+or the default files `$HOME/.openmpi/mca-params.conf` (per user) and
+`$prefix/etc/openmpi-mca-params.conf` (system-wide), with one `name = value`
+per line:
+
+```ini
+# ~/.openmpi/mca-params.conf
+btl = tcp,self,sm
+btl_tcp_if_include = 192.168.1.0/24
+```
+
+> **Note:** PMIx and PRRTE (Open MPI's run-time dependencies) have their own
+> MCA systems. Their parameters use the `--pmixmca` / `--prtemca` command-line
+> options and the `PMIX_MCA_` / `PRTE_MCA_` environment-variable prefixes
+> (note the single "R" in `PRTE_MCA_`), not `--mca` / `OMPI_MCA_`.
+
+For guidance on *which* parameters to set for a given network, accelerator, or
+workload, see the human-facing "Tuning MPI applications" documentation and the
+"Modular Component Architecture (MCA)" section of the Open MPI documentation.
diff --git a/docs/man-openmpi/man1/mpijavac.1 b/docs/man-openmpi/man1/mpijavac.1
deleted file mode 100644
index 7b464ffa102..00000000000
--- a/docs/man-openmpi/man1/mpijavac.1
+++ /dev/null
@@ -1 +0,0 @@
-.so man1/ompi-wrapper-compiler.1
diff --git a/docs/man-openmpi/man1/mpirun.1.rst b/docs/man-openmpi/man1/mpirun.1.rst
index 33412896104..5eec1816613 100644
--- a/docs/man-openmpi/man1/mpirun.1.rst
+++ b/docs/man-openmpi/man1/mpirun.1.rst
@@ -267,10 +267,13 @@ To map processes:
 
 * ``--cpu-list <cpus>``: Comma-delimited list of processor IDs to
   which to bind processes [default=``NULL``].  Processor IDs are
-  interpreted as hwloc logical core IDs.
+  interpreted as `Hwloc <https://www.open-mpi.org/projects/hwloc/>`_
+  logical core IDs.
 
-  .. note:: You can run Run the hwloc ``lstopo(1)`` command to see a
-            list of available cores and their logical IDs.
+  .. note:: You can run the `Hwloc
+            <https://www.open-mpi.org/projects/hwloc/>`_ ``lstopo(1)``
+            command to see a list of available cores and their logical
+            IDs.
 
 To order processes' ranks in ``MPI_COMM_WORLD``:
 
@@ -1157,7 +1160,7 @@ If only ``--bind-to OBJ`` is specified, then ``--map-by`` is determined by the n
   R2  hostA  [../../../../../../../..][BB/../../../../../../..]
   R3  hostA  [../../../../../../../..][../BB/../../../../../..]
 
-The mapping pattern might be better seen if we change the default ``--rank-by`` from ``fill`` to ``span``. First, the processes are mapped by package iterating between the two marking a core at a time. Next, the processes are ranked in a spanning manner that load balances them across the object they were mapped against. Finally, the processes are bound to the core that they were mapped againast.
+The mapping pattern might be better seen if we change the default ``--rank-by`` from ``fill`` to ``span``. First, the processes are mapped by package iterating between the two marking a core at a time. Next, the processes are ranked in a spanning manner that load balances them across the object they were mapped against. Finally, the processes are bound to the core that they were mapped against.
 
 .. code::
 
@@ -1206,12 +1209,12 @@ Means that:
 * Rank 1 runs on node bb, bound to logical package 0, cores 0 and 1.
 * Rank 2 runs on node cc, bound to logical cores 2 and 3.
 
-Note that only logicical processor locations are supported. By default, the values specified are assumed to be cores. If you intend to specify specific hardware threads then you must add the ``:hwtcpus`` qualifier to the ``--map-by`` command line option (e.g., ``--map-by rankfile:file=myrankfile:hwtcpus``).
+Note that only logical processor locations are supported. By default, the values specified are assumed to be cores. If you intend to specify specific hardware threads then you must add the ``:hwtcpus`` qualifier to the ``--map-by`` command line option (e.g., ``--map-by rankfile:file=myrankfile:hwtcpus``).
 
 If the binding specification overlaps between any two ranks then an error occurs. If you intend to allow processes to share the same logical processing unit then you must pass the ``--bind-to :overload-allowed`` command line option to tell the runtime to ignore this check.
 
 The hostnames listed above are "absolute," meaning that actual
-resolveable hostnames are specified.  However, hostnames can also be
+resolvable hostnames are specified.  However, hostnames can also be
 specified as "relative," meaning that they are specified in relation
 to an externally-specified list of hostnames (e.g., by ``mpirun``'s
 ``--host`` argument, a hostfile, or a job scheduler).
@@ -1230,10 +1233,11 @@ hostnames, indexed from 0.  For example:
 
 All package/core slot locations are specified as logical indexes.
 
-.. note:: The Open MPI v1.6 series used physical indexes. Starting in Open MPI v5.0 only logicial indexes are supported and the ``rmaps_rank_file_physical`` MCA parameter is no longer recognized.
+.. note:: The Open MPI v1.6 series used physical indexes. Starting in Open MPI v5.0 only logical indexes are supported and the ``rmaps_rank_file_physical`` MCA parameter is no longer recognized.
 
-You can use tools such as Hwloc's `lstopo(1)` to find the logical
-indexes of package and cores.
+You can use tools such as `Hwloc's
+<https://www.open-mpi.org/projects/hwloc/>`_ ``lstopo(1)`` command to
+find the logical indexes of package and cores.
 
 Application Context or Executable Program?
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/docs/man-openmpi/man1/ompi-wrapper-compiler.1.rst b/docs/man-openmpi/man1/ompi-wrapper-compiler.1.rst
index 249de903ad2..ff27686f80d 100644
--- a/docs/man-openmpi/man1/ompi-wrapper-compiler.1.rst
+++ b/docs/man-openmpi/man1/ompi-wrapper-compiler.1.rst
@@ -2,14 +2,13 @@
 .. _man1-mpic++:
 .. _man1-mpicxx:
 .. _man1-mpifort:
-.. _man1-mpijavac:
 
 Open MPI Wrapper Compilers
 ==========================
 
 .. include_body
 
-mpicc, mpic++, mpicxx, mpifort, mpijavac |mdash| Open MPI wrapper compilers
+mpicc, mpic++, mpicxx, mpifort |mdash| Open MPI wrapper compilers
 
 SYNTAX
 ------
@@ -22,8 +21,6 @@ SYNTAX
 
 ``mpifort [--showme | --showme:compile | --showme:link] ...``
 
-``mpijavac [--showme | --showme:compile | --showme:link] ...``
-
 The following deprecated commands are also available |mdash| but
 ``mpifort`` should be used instead:
 
@@ -117,11 +114,9 @@ Open MPI provides wrapper compilers for several languages:
             underlying C++ compiler with the same options. All are
             provided as compatibility with other MPI implementations.
 
-* ``mpifort`` (and its legacy/deprecated aliaes ``mpif77`` and
+* ``mpifort`` (and its legacy/deprecated aliases ``mpif77`` and
   ``mpif90``): Fortran
 
-* ``mpijavac``: Java
-
 The wrapper compilers for each of the languages are identical; they
 can be use interchangeably.  The different names are provided solely
 for backwards compatibility.
diff --git a/docs/man-openmpi/man3/MPIX_Comm_ack_failed.3.rst b/docs/man-openmpi/man3/MPIX_Comm_ack_failed.3.rst
index 0302b889a5b..b02e3de4dcd 100644
--- a/docs/man-openmpi/man3/MPIX_Comm_ack_failed.3.rst
+++ b/docs/man-openmpi/man3/MPIX_Comm_ack_failed.3.rst
@@ -90,7 +90,7 @@ class MPI_ERR_PROC_FAILED due to this acknowledged failure.
 USAGE PATTERNS
 --------------
 
-One may query, without side effect, for the number of currently aknowledged
+One may query, without side effect, for the number of currently acknowledged
 process failures *comm* by supplying 0 in *num_to_ack*.
 
 Conversely, one may unconditionally acknowledge all currently known process
diff --git a/docs/man-openmpi/man3/MPIX_Comm_shrink.3.rst b/docs/man-openmpi/man3/MPIX_Comm_shrink.3.rst
index 1bbf94ba44c..0b7ad568177 100644
--- a/docs/man-openmpi/man3/MPIX_Comm_shrink.3.rst
+++ b/docs/man-openmpi/man3/MPIX_Comm_shrink.3.rst
@@ -104,7 +104,7 @@ group of *comm* contains failed MPI processes. In particular,
 even when *comm* is revoked.
 
 The implementation will strive to detect all failures during the shrink
-operation, but in certain circumpstances, the group of *newcomm* may still
+operation, but in certain circumstances, the group of *newcomm* may still
 contain failed MPI processes, whose failure will be detected in subsequent
 MPI operations on *newcomm*.
 
diff --git a/docs/man-openmpi/man3/MPIX_Query_cuda_support.3.rst b/docs/man-openmpi/man3/MPIX_Query_cuda_support.3.rst
index 302c478b60b..9635f3f6edf 100644
--- a/docs/man-openmpi/man3/MPIX_Query_cuda_support.3.rst
+++ b/docs/man-openmpi/man3/MPIX_Query_cuda_support.3.rst
@@ -41,7 +41,7 @@ DESCRIPTION
 -----------
 
 This function is part of an :ref:`Open MPI extension
-<ompi-features-extentions-label>`; it is not part of standard MPI.
+<ompi-features-extensions-label>`; it is not part of standard MPI.
 
 This routine returns 1 if both the MPI library was built with the
 NVIDIA CUDA library and the runtime supports CUDA buffers.  Otherwise,
diff --git a/docs/man-openmpi/man3/MPIX_Query_rocm_support.3.rst b/docs/man-openmpi/man3/MPIX_Query_rocm_support.3.rst
index 59f6148079a..005a4176e50 100644
--- a/docs/man-openmpi/man3/MPIX_Query_rocm_support.3.rst
+++ b/docs/man-openmpi/man3/MPIX_Query_rocm_support.3.rst
@@ -41,7 +41,7 @@ DESCRIPTION
 -----------
 
 This function is part of an :ref:`Open MPI extension
-<ompi-features-extentions-label>`; it is not part of standard MPI.
+<ompi-features-extensions-label>`; it is not part of standard MPI.
 
 This routine returns 1 if both the MPI library was built with the AMD
 ROCm library and the runtime supports ROCm buffers.  Otherwise, it
diff --git a/docs/man-openmpi/man3/MPI_Allgather.3.rst b/docs/man-openmpi/man3/MPI_Allgather.3.rst
index 2d7926bb5cb..9013adae7ff 100644
--- a/docs/man-openmpi/man3/MPI_Allgather.3.rst
+++ b/docs/man-openmpi/man3/MPI_Allgather.3.rst
@@ -112,7 +112,7 @@ first group and received by all the members of the second group. Then
 the data is gathered from all the members of the second group and
 received by all the members of the first. The operation, however, need
 not be symmetric. The number of items sent by the processes in first
-group need not be equal to the number of items sent by the the processes
+group need not be equal to the number of items sent by the processes
 in the second group. You can move data in only one direction by giving
 *sendcount* a value of 0 for communication in the reverse direction.
 
diff --git a/docs/man-openmpi/man3/MPI_Buffer_flush.3.rst b/docs/man-openmpi/man3/MPI_Buffer_flush.3.rst
index e712479baac..5446825e827 100644
--- a/docs/man-openmpi/man3/MPI_Buffer_flush.3.rst
+++ b/docs/man-openmpi/man3/MPI_Buffer_flush.3.rst
@@ -6,7 +6,7 @@ MPI_Buffer_flush
 .. include_body
 
 :ref:`MPI_Buffer_flush`, :ref:`MPI_Buffer_iflush` |mdash| Wait till all messages currently in 
-the the MPI process specific buffer of the calling MPI process have been transmitted.
+the MPI process specific buffer of the calling MPI process have been transmitted.
 
 .. The following directive tells the man page generation script to
    generate multiple bindings for this file.
diff --git a/docs/man-openmpi/man3/MPI_Comm_set_info.3.rst b/docs/man-openmpi/man3/MPI_Comm_set_info.3.rst
index e94d51e83e4..7f1892760af 100644
--- a/docs/man-openmpi/man3/MPI_Comm_set_info.3.rst
+++ b/docs/man-openmpi/man3/MPI_Comm_set_info.3.rst
@@ -26,7 +26,7 @@ DESCRIPTION
 :ref:`MPI_Comm_set_info` sets new values for the hints of the communicator
 associated with *comm*. :ref:`MPI_Comm_set_info` is a collective routine. The
 info object may be different on each process, but any info entries that
-an implementation requires to be the same on all processes must appear
+an implementation requires to have identical values on all processes must appear
 with the same value in each process's *info* object.
 
 The following info key assertions may be accepted by Open MPI:
diff --git a/docs/man-openmpi/man3/MPI_Comm_split_type.3.rst b/docs/man-openmpi/man3/MPI_Comm_split_type.3.rst
index 74651ea0b47..2f462fffd39 100644
--- a/docs/man-openmpi/man3/MPI_Comm_split_type.3.rst
+++ b/docs/man-openmpi/man3/MPI_Comm_split_type.3.rst
@@ -103,6 +103,12 @@ OMPI_COMM_TYPE_CLUSTER
    This type splits the communicator into subcommunicators, each of
    which belongs to the same cluster.
 
+OMPI_COMM_TYPE_NVLINK
+   This type splits the communicator into subcommunicators based on
+   the NVLink domain associated with each process. It may also be
+   requested via ``MPI_COMM_TYPE_HW_GUIDED`` with
+   ``mpi_hw_resource_type`` set to ``nvlink``.
+
 
 NOTES
 -----
diff --git a/docs/man-openmpi/man3/MPI_Dist_graph_create.3.rst b/docs/man-openmpi/man3/MPI_Dist_graph_create.3.rst
index 51c98bc3fd2..6452255d2e8 100644
--- a/docs/man-openmpi/man3/MPI_Dist_graph_create.3.rst
+++ b/docs/man-openmpi/man3/MPI_Dist_graph_create.3.rst
@@ -48,7 +48,7 @@ this edge is stored in
 *weights*\ [*degrees*\ [0]+...+\ *degrees*\ [i-1]+j]. Both the *sources*
 and the *destinations* arrays may contain the same node more than once,
 and the order in which nodes are listed as destinations or sources is
-not signicant. Similarly, different processes may specify edges with the
+not significant. Similarly, different processes may specify edges with the
 same source and destination nodes. Source and destination nodes must be
 process ranks of comm_old. Different processes may specify different
 numbers of source and destination nodes, as well as different source to
diff --git a/docs/man-openmpi/man3/MPI_F_sync_reg.3.rst b/docs/man-openmpi/man3/MPI_F_sync_reg.3.rst
new file mode 100644
index 00000000000..678304bca23
--- /dev/null
+++ b/docs/man-openmpi/man3/MPI_F_sync_reg.3.rst
@@ -0,0 +1,48 @@
+.. _mpi_f_sync_reg:
+
+
+MPI_F_sync_reg
+==============
+
+.. include_body
+
+:ref:`MPI_F_sync_reg` |mdash| Prevent invalid register optimization of a Fortran buffer
+
+.. The following file was automatically generated
+.. include:: ./bindings/mpi_f_sync_reg.rst
+
+INPUT/OUTPUT PARAMETERS
+-----------------------
+* ``buf``: Initial address of the buffer (choice).
+
+DESCRIPTION
+-----------
+
+:ref:`MPI_F_sync_reg` has no executable statements; it exists only to prevent
+a Fortran compiler from making invalid assumptions about the contents of a
+buffer across an operation that the compiler cannot see. Passing *buf* to this
+routine forces the compiler, when necessary, to flush a cached register copy
+of the buffer back to memory, or to invalidate a cached register copy so that
+the buffer is reloaded from memory on its next use.
+
+This is needed in Fortran code that aggressively optimizes register usage
+around nonblocking or one-sided operations, whose completion |mdash| and
+therefore whose effect on the buffer |mdash| is not visible to the compiler
+from the surrounding code.
+
+
+NOTES
+-----
+
+This routine is provided only in the Fortran bindings; it has no C binding
+because it would serve no purpose in C. It also has no *ierror* argument
+because there is no operation that can fail.
+
+For example, after an :ref:`MPI_Wait` that completes a nonblocking receive
+into *buf*, a call to ``MPI_F_sync_reg(buf)`` ensures that the compiler
+reloads *buf* from memory rather than reusing a stale register copy that
+predates the receive.
+
+
+.. seealso::
+   * :ref:`MPI_Wait`
diff --git a/docs/man-openmpi/man3/MPI_Fetch_and_op.3.rst b/docs/man-openmpi/man3/MPI_Fetch_and_op.3.rst
index 48b163f0eee..f2f5e884ca8 100644
--- a/docs/man-openmpi/man3/MPI_Fetch_and_op.3.rst
+++ b/docs/man-openmpi/man3/MPI_Fetch_and_op.3.rst
@@ -46,7 +46,7 @@ the associative function f(a, b) =b; that is, the current value in the
 target memory is replaced by the value supplied by the origin.
 
 A new predefined operation, MPI_NO_OP, is defined. It corresponds to the
-assiciative function f(a, b) = a; that is the current value in the
+associative function f(a, b) = a; that is the current value in the
 target memory is returned in the result buffer at the origin and no
 operation is performed on the target buffer.
 
diff --git a/docs/man-openmpi/man3/MPI_File_get_info.3.rst b/docs/man-openmpi/man3/MPI_File_get_info.3.rst
index 24f7a3f2e86..e1de4bb9c38 100644
--- a/docs/man-openmpi/man3/MPI_File_get_info.3.rst
+++ b/docs/man-openmpi/man3/MPI_File_get_info.3.rst
@@ -44,62 +44,7 @@ hints that can be set.
 HINTS
 -----
 
-The following hints can be used as values for the *info_used* argument.
-
-**SETTABLE HINTS**
-
-* ``shared_file_timeout``: Amount of time (in seconds) to wait for
-  access to the shared file pointer before exiting with
-  ``MPI_ERR_TIMEDOUT``.
-
-* ``rwlock_timeout``: Amount of time (in seconds) to wait for
-  obtaining a read or write lock on a contiguous chunk of a UNIX file
-  before exiting with ``MPI_ERR_TIMEDOUT``.
-
-* ``noncoll_read_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy read requests in the noncollective data-access
-  routines.
-
-  .. note:: A buffer size smaller than the distance (in bytes) in a
-            UNIX file between the first byte and the last byte of the
-            access request causes MPI I/O to iterate and perform
-            multiple UNIX ``read()`` or ``write()`` calls. If the
-            request includes multiple noncontiguous chunks of data,
-            and the buffer size is greater than the size of those
-            chunks, then the UNIX ``read()`` or ``write()`` (made at
-            the MPI I/O level) will access data not requested by this
-            process in order to reduce the total number of ``write()``
-            calls made. If this is not desirable behavior, you should
-            reduce this buffer size to equal the size of the
-            contiguous chunks within the aggregate request.
-
-* ``noncoll_write_bufsize``: Maximum size of the buffer used by MPI
-  I/O to satisfy write requests in the noncollective data-access
-  routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_read_bufsize``: Maximum size of the buffer used by MPI I/O to
-  satisfy read requests in the collective data-access routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_write_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy write requests in the collective data-access
-  routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``mpiio_concurrency``: (boolean) controls whether nonblocking
-  I/O routines can bind an extra thread to an LWP.
-
-* ``mpiio_coll_contiguous``: (boolean) controls whether subsequent
-  collective data accesses will request collectively contiguous
-  regions of the file.
-
-**NON-SETTABLE HINTS**
-
-* ``filename``: Access this hint to get the name of the file.
+.. include:: /tuning-apps/_include/ompio-mpi-info-hints.rst
 
 
 
diff --git a/docs/man-openmpi/man3/MPI_File_open.3.rst b/docs/man-openmpi/man3/MPI_File_open.3.rst
index 0b0be6cba49..7a8644be276 100644
--- a/docs/man-openmpi/man3/MPI_File_open.3.rst
+++ b/docs/man-openmpi/man3/MPI_File_open.3.rst
@@ -83,65 +83,7 @@ hints that can be set.
 HINTS
 -----
 
-The following hints can be used as values for the *info* argument.
-
-**SETTABLE HINTS**
-
-* ``MPI_INFO_NULL``
-
-* ``shared_file_timeout``: Amount of time (in seconds) to wait for
-  access to the shared file pointer before exiting with
-  ``MPI_ERR_TIMEDOUT``.
-
-* ``rwlock_timeout``: Amount of time (in seconds) to wait for
-  obtaining a read or write lock on a contiguous chunk of a UNIX file
-  before exiting with ``MPI_ERR_TIMEDOUT``.
-
-* ``noncoll_read_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy multiple noncontiguous read requests in the noncollective
-  data-access routines.
-
-  .. note:: A buffer size smaller than the distance (in bytes) in a
-            UNIX file between the first byte and the last byte of the
-            access request causes MPI I/O to iterate and perform
-            multiple UNIX `read()` or `write()` calls. If the request
-            includes multiple noncontiguous chunks of data, and the
-            buffer size is greater than the size of those chunks, then
-            the UNIX `read()` or `write()` (made at the MPI I/O level)
-            will access data not requested by this process in order to
-            reduce the total number of `write()` calls made. If this
-            is not desirable behavior, you should reduce this buffer
-            size to equal the size of the contiguous chunks within the
-            aggregate request.
-
-* ``noncoll_write_bufsize``: Maximum size of the buffer used by MPI
-  I/O to satisfy multiple noncontiguous write requests in the
-  noncollective data-access routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_read_bufsize``: Maximum size of the buffer used by MPI I/O to
-  satisfy multiple noncontiguous read requests in the collective
-  data-access routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_write_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy multiple noncontiguous write requests in the collective
-  data-access routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``mpiio_concurrency``: (boolean) controls whether nonblocking I/O
-  routines can bind an extra thread to an LWP.  .sp
-
-* ``mpiio_coll_contiguous``: (boolean) controls whether subsequent
-  collective data accesses will request collectively contiguous
-  regions of the file.
-
-**NON-SETTABLE HINTS**
-
-* ``filename``: Access this hint to get the name of the file.
+.. include:: /tuning-apps/_include/ompio-mpi-info-hints.rst
 
 
 ERRORS
diff --git a/docs/man-openmpi/man3/MPI_File_set_info.3.rst b/docs/man-openmpi/man3/MPI_File_set_info.3.rst
index 76253fe2b5a..b8bb4e24533 100644
--- a/docs/man-openmpi/man3/MPI_File_set_info.3.rst
+++ b/docs/man-openmpi/man3/MPI_File_set_info.3.rst
@@ -42,63 +42,7 @@ for a list of hints that can be set.
 HINTS
 -----
 
-The following hints can be used as values for the *info* argument.
-
-**SETTABLE HINTS**
-
-* ``shared_file_timeout``: Amount of time (in seconds) to wait for
-  access to the shared file pointer before exiting with
-  ``MPI_ERR_TIMEDOUT``.
-
-* ``rwlock_timeout``: Amount of time (in seconds) to wait for
-  obtaining a read or write lock on a contiguous chunk of a UNIX file
-  before exiting with ``MPI_ERR_TIMEDOUT``.
-
-* ``noncoll_read_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy read requests in the noncollective data-access
-  routines.
-
-  .. note:: A buffer size smaller than the distance (in bytes) in a
-	    UNIX file between the first byte and the last byte of the
-	    access request causes MPI I/O to iterate and perform
-	    multiple UNIX ``read()`` or ``write()`` calls. If the request
-	    includes multiple noncontiguous chunks of data, and the
-	    buffer size is greater than the size of those chunks, then
-	    the UNIX ``read()`` or ``write()`` (made at the MPI I/O level)
-	    will access data not requested by this process in order to
-	    reduce the total number of ``write()`` calls made. If this is
-	    not desirable behavior, you should reduce this buffer size
-	    to equal the size of the contiguous chunks within the
-	    aggregate request.
-
-* ``noncoll_write_bufsize``: Maximum size of the buffer used by MPI
-  I/O to satisfy write requests in the noncollective data-access
-  routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_read_bufsize``: Maximum size of the buffer used by MPI I/O to
-  satisfy read requests in the collective data-access routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_write_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy write requests in the collective data-access
-  routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``mpiio_concurrency``: (boolean) controls whether nonblocking I/O
-  routines can bind an extra thread to an LWP.
-
-* ``mpiio_coll_contiguous``: (boolean) controls whether subsequent
-  collective data accesses will request collectively contiguous
-  regions of the file.
-
-
-  **NON-SETTABLE HINTS**
-
-* ``filename``: Access this hint to get the name of the file.
+.. include:: /tuning-apps/_include/ompio-mpi-info-hints.rst
 
 
 ERRORS
diff --git a/docs/man-openmpi/man3/MPI_File_set_view.3.rst b/docs/man-openmpi/man3/MPI_File_set_view.3.rst
index d2d00ec229e..f211e99d4cd 100644
--- a/docs/man-openmpi/man3/MPI_File_set_view.3.rst
+++ b/docs/man-openmpi/man3/MPI_File_set_view.3.rst
@@ -59,62 +59,7 @@ set.
 HINTS
 -----
 
-The following hints can be used as values for the *info* argument.
-
-**SETTABLE HINTS**
-
-* ``MPI_INFO_NULL``
-
-* ``shared_file_timeout``: Amount of time (in seconds) to wait for
-  access to the shared file pointer before exiting with
-  ``MPI_ERR_TIMEDOUT``.
-
-* ``rwlock_timeout``: Amount of time (in seconds) to wait for
-  obtaining a read or write lock on a contiguous chunk of a UNIX file
-  before exiting with ``MPI_ERR_TIMEDOUT``.
-
-* ``noncoll_read_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy read requests in the noncollective data-access routines.
-
-  .. note:: A buffer size smaller than the distance (in bytes) in a
-            UNIX file between the first byte and the last byte of the
-            access request causes MPI I/O to iterate and perform
-            multiple UNIX ``read()`` or ``write()`` calls. If the
-            request includes multiple noncontiguous chunks of data,
-            and the buffer size is greater than the size of those
-            chunks, then the UNIX ``read()`` or ``write()`` (made at
-            the MPI I/O level) will access data not requested by this
-            process in order to reduce the total number of ``write()``
-            calls made. If this is not desirable behavior, you should
-            reduce this buffer size to equal the size of the
-            contiguous chunks within the aggregate request.
-
-* ``noncoll_write_bufsize``: Maximum size of the buffer used by MPI
-  I/O to satisfy write requests in the noncollective data-access
-  routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_read_bufsize``: Maximum size of the buffer used by MPI I/O to
-  satisfy read requests in the collective data-access routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``coll_write_bufsize``: Maximum size of the buffer used by MPI I/O
-  to satisfy write requests in the collective data-access routines.
-
-  See the above note in ``noncoll_read_bufsize``.
-
-* ``mpiio_concurrency``: (boolean) controls whether nonblocking I/O
-  routines can bind an extra thread to an LWP.
-
-* ``mpiio_coll_contiguous``: (boolean) controls whether subsequent
-  collective data accesses will request collectively contiguous
-  regions of the file.
-
-**NON-SETTABLE HINTS**
-
-* ``filename``: Access this hint to get the name of the file.
+.. include:: /tuning-apps/_include/ompio-mpi-info-hints.rst
 
 
 ERRORS
diff --git a/docs/man-openmpi/man3/MPI_Finalize.3.rst b/docs/man-openmpi/man3/MPI_Finalize.3.rst
index bf52247e205..faad83e83dc 100644
--- a/docs/man-openmpi/man3/MPI_Finalize.3.rst
+++ b/docs/man-openmpi/man3/MPI_Finalize.3.rst
@@ -65,7 +65,7 @@ some other verification of completion.
 
 For example, a successful return from a blocking communication
 operation or from one of the :ref:`MPI_Wait` or :ref:`MPI_Test`
-varients means that the communication is completed by the user and the
+variants means that the communication is completed by the user and the
 buffer can be reused, but does not guarantee that the local process
 has no more work to do. Similarly, a successful return from
 :ref:`MPI_Request_free` with a request handle generated by an
diff --git a/docs/man-openmpi/man3/MPI_Get_accumulate.3.rst b/docs/man-openmpi/man3/MPI_Get_accumulate.3.rst
index 5a717ef5836..68e47135c71 100644
--- a/docs/man-openmpi/man3/MPI_Get_accumulate.3.rst
+++ b/docs/man-openmpi/man3/MPI_Get_accumulate.3.rst
@@ -70,7 +70,7 @@ the associative function f(a, b) =b; that is, the current value in the
 target memory is replaced by the value supplied by the origin.
 
 A new predefined operation, MPI_NO_OP, is defined. It corresponds to the
-assiciative function f(a, b) = a; that is the current value in the
+associative function f(a, b) = a; that is the current value in the
 target memory is returned in the result buffer at the origin and no
 operation is performed on the target buffer.
 
diff --git a/docs/man-openmpi/man3/MPI_Init.3.rst b/docs/man-openmpi/man3/MPI_Init.3.rst
index 6df7d039cc2..b3bd1182c89 100644
--- a/docs/man-openmpi/man3/MPI_Init.3.rst
+++ b/docs/man-openmpi/man3/MPI_Init.3.rst
@@ -45,7 +45,7 @@ interprets, nor distributes them:
 
    int main(int argv, char *argv[]) {
        MPI_Init(&argc, &argv);
-       /* ...body of main MPI pogram... */
+       /* ...body of main MPI program... */
        MPI_Finalize();
        return 0;
    }
diff --git a/docs/man-openmpi/man3/MPI_Init_thread.3.rst b/docs/man-openmpi/man3/MPI_Init_thread.3.rst
index 8d77ba17d50..e9068b0c20d 100644
--- a/docs/man-openmpi/man3/MPI_Init_thread.3.rst
+++ b/docs/man-openmpi/man3/MPI_Init_thread.3.rst
@@ -58,7 +58,7 @@ neither modifies, interprets, nor distributes them:
    int main(int argv, char *argv[]) {
        int provided;
        MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
-       /* ...body of main MPI pogram... */
+       /* ...body of main MPI program... */
        MPI_Finalize();
        return 0;
    }
@@ -142,7 +142,7 @@ of the values listed below.
           environment variable.
 
           Starting with Open MPI v6.0.0, the Open MPI community
-          recomends using one of the string name variants so that it
+          recommends using one of the string name variants so that it
           can be correctly mapped to the corresponding Open MPI ABI
           value or the MPI Standard ABI value, as relevant.
 
diff --git a/docs/man-openmpi/man3/MPI_Reduce_scatter_block.3.rst b/docs/man-openmpi/man3/MPI_Reduce_scatter_block.3.rst
index 0d4ab22de09..ee1188af231 100644
--- a/docs/man-openmpi/man3/MPI_Reduce_scatter_block.3.rst
+++ b/docs/man-openmpi/man3/MPI_Reduce_scatter_block.3.rst
@@ -20,7 +20,7 @@ results in blocks.
 INPUT PARAMETERS
 ----------------
 * ``sendbuf``: Starting address of send buffer (choice).
-* ``recvcount``: lement count per block (non-negative integer).
+* ``recvcount``: Element count per block (non-negative integer).
 * ``datatype``: Datatype of elements of input buffer (handle).
 * ``op``: Operation (handle).
 * ``comm``: Communicator (handle).
diff --git a/docs/man-openmpi/man3/MPI_Session_get_num_psets.3.rst b/docs/man-openmpi/man3/MPI_Session_get_num_psets.3.rst
index 032080dd172..839da2ea922 100644
--- a/docs/man-openmpi/man3/MPI_Session_get_num_psets.3.rst
+++ b/docs/man-openmpi/man3/MPI_Session_get_num_psets.3.rst
@@ -20,7 +20,7 @@ INPUT PARAMETERS
 OUTPUT PARAMETERS
 -----------------
 
-* ``npset_names`` : number of available process sets (non-negtive integer)
+* ``npset_names`` : number of available process sets (non-negative integer)
 * ``ierror`` : Fortran only: Error status (integer).
 
 DESCRIPTION
diff --git a/docs/man-openmpi/man3/MPI_Session_set_errhandler.3.rst b/docs/man-openmpi/man3/MPI_Session_set_errhandler.3.rst
index 7ada2ebb545..bc7d253e8f8 100644
--- a/docs/man-openmpi/man3/MPI_Session_set_errhandler.3.rst
+++ b/docs/man-openmpi/man3/MPI_Session_set_errhandler.3.rst
@@ -29,6 +29,21 @@ The error handler must be either a predefined error handler or an error
 handler created by a call to :ref:`MPI_Session_create_errhandler`.
 
 
+NOTES
+-----
+
+When using MPI_ERRORS_ABORT with a session, note that per MPI-5.0 Sec 9.3
+(pp.447-448), this error handler aborts ONLY the local MPI process, not the
+entire job. When using the PRRTE runtime (the default for Open MPI), you must
+use the ``--enable-recovery`` option with ``mpirun(1)`` or ``mpiexec(1)`` to
+prevent the runtime from automatically aborting other processes in the job
+when the local process aborts.
+
+For example::
+
+   mpirun --enable-recovery -n 4 ./my_program
+
+
 ERRORS
 ------
 
diff --git a/docs/man-openmpi/man3/MPI_T_category_get_index.3.rst b/docs/man-openmpi/man3/MPI_T_category_get_index.3.rst
new file mode 100644
index 00000000000..e9849463531
--- /dev/null
+++ b/docs/man-openmpi/man3/MPI_T_category_get_index.3.rst
@@ -0,0 +1,61 @@
+.. _mpi_t_category_get_index:
+
+
+MPI_T_category_get_index
+========================
+
+.. include_body
+
+:ref:`MPI_T_category_get_index` |mdash| Query the index of a category from its name
+
+.. The following file was automatically generated
+.. include:: ./bindings/mpi_t_category_get_index.rst
+
+INPUT PARAMETERS
+----------------
+* ``name``: Name of the category to query.
+
+OUTPUT PARAMETERS
+-----------------
+* ``cat_index``: Index of the category.
+
+DESCRIPTION
+-----------
+
+:ref:`MPI_T_category_get_index` can be used to retrieve the index of a
+category given its name. The *name* argument is provided by the caller as a
+null-terminated string, and the matching index is returned in *cat_index*.
+The returned index can then be passed to other MPI tool information interface
+routines, such as :ref:`MPI_T_category_get_info`.
+
+This routine allows a tool to look up a category by name without iterating
+over the entire set of categories. Because the number of categories exposed
+by the implementation can change over time, this is both more convenient and
+lower overhead than enumerating all of the categories to find a particular
+one.
+
+
+NOTES
+-----
+
+Category names are implementation-specific. Looking a category up by name is
+therefore not portable across MPI implementations, but may be the preferred
+approach for a tool that targets Open MPI specifically.
+
+
+ERRORS
+------
+
+:ref:`MPI_T_category_get_index` will fail if:
+
+* ``MPI_T_ERR_NOT_INITIALIZED``: The MPI Tools interface is not initialized.
+
+* ``MPI_T_ERR_INVALID``: ``name`` or ``cat_index`` is ``NULL``.
+
+* ``MPI_T_ERR_INVALID_NAME``: ``name`` does not match the name of any category
+  provided by the implementation at the time of the call.
+
+
+.. seealso::
+   * :ref:`MPI_T_category_get_info`
+   * :ref:`MPI_T_category_get_num`
diff --git a/docs/man-openmpi/man3/MPI_T_category_get_num_events.3.rst b/docs/man-openmpi/man3/MPI_T_category_get_num_events.3.rst
index e3294c15675..4671ef8924b 100644
--- a/docs/man-openmpi/man3/MPI_T_category_get_num_events.3.rst
+++ b/docs/man-openmpi/man3/MPI_T_category_get_num_events.3.rst
@@ -33,3 +33,5 @@ ERRORS
 :ref:`MPI_T_category_get_num_events` will fail if:
 
 * ``MPI_T_ERR_NOT_INITIALIZED``: The MPI Tools interface not initialized
+
+* ``MPI_T_ERR_INVALID_INDEX``: The category index is invalid
diff --git a/docs/man-openmpi/man3/MPI_T_cvar_get_index.3.rst b/docs/man-openmpi/man3/MPI_T_cvar_get_index.3.rst
new file mode 100644
index 00000000000..b695f2ec882
--- /dev/null
+++ b/docs/man-openmpi/man3/MPI_T_cvar_get_index.3.rst
@@ -0,0 +1,62 @@
+.. _mpi_t_cvar_get_index:
+
+
+MPI_T_cvar_get_index
+====================
+
+.. include_body
+
+:ref:`MPI_T_cvar_get_index` |mdash| Query the index of a control variable from its name
+
+.. The following file was automatically generated
+.. include:: ./bindings/mpi_t_cvar_get_index.rst
+
+INPUT PARAMETERS
+----------------
+* ``name``: Name of the control variable to query.
+
+OUTPUT PARAMETERS
+-----------------
+* ``cvar_index``: Index of the control variable.
+
+DESCRIPTION
+-----------
+
+:ref:`MPI_T_cvar_get_index` can be used to retrieve the index of a control
+variable given its name. The *name* argument is provided by the caller as a
+null-terminated string, and the matching index is returned in *cvar_index*.
+The returned index can then be passed to other MPI tool information
+interface routines, such as :ref:`MPI_T_cvar_get_info`. Control variables in
+Open MPI are the same as MCA parameters.
+
+This routine allows a tool to look up a control variable by name without
+iterating over the entire set of control variables. Because the number of
+control variables exposed by the implementation can change over time, this is
+both more convenient and lower overhead than enumerating all of the variables
+to find a particular one.
+
+
+NOTES
+-----
+
+Control variable names are implementation-specific. Looking a variable up by
+name is therefore not portable across MPI implementations, but may be the
+preferred approach for a tool that targets Open MPI specifically.
+
+
+ERRORS
+------
+
+:ref:`MPI_T_cvar_get_index` will fail if:
+
+* ``MPI_T_ERR_NOT_INITIALIZED``: The MPI Tools interface is not initialized.
+
+* ``MPI_T_ERR_INVALID``: ``name`` or ``cvar_index`` is ``NULL``.
+
+* ``MPI_T_ERR_INVALID_NAME``: ``name`` does not match the name of any control
+  variable provided by the implementation at the time of the call.
+
+
+.. seealso::
+   * :ref:`MPI_T_cvar_get_info`
+   * :ref:`MPI_T_cvar_get_num`
diff --git a/docs/man-openmpi/man3/MPI_T_pvar_get_index.3.rst b/docs/man-openmpi/man3/MPI_T_pvar_get_index.3.rst
new file mode 100644
index 00000000000..6017e152346
--- /dev/null
+++ b/docs/man-openmpi/man3/MPI_T_pvar_get_index.3.rst
@@ -0,0 +1,65 @@
+.. _mpi_t_pvar_get_index:
+
+
+MPI_T_pvar_get_index
+====================
+
+.. include_body
+
+:ref:`MPI_T_pvar_get_index` |mdash| Query the index of a performance variable from its name
+
+.. The following file was automatically generated
+.. include:: ./bindings/mpi_t_pvar_get_index.rst
+
+INPUT PARAMETERS
+----------------
+* ``name``: Name of the performance variable to query.
+* ``var_class``: Class of the performance variable to query.
+
+OUTPUT PARAMETERS
+-----------------
+* ``pvar_index``: Index of the performance variable.
+
+DESCRIPTION
+-----------
+
+:ref:`MPI_T_pvar_get_index` can be used to retrieve the index of a
+performance variable given its name and class. The *name* and *var_class*
+arguments are provided by the caller |mdash| *name* as a null-terminated
+string |mdash| and the matching index is returned in *pvar_index*. A
+performance variable is identified by the pair (*name*, *var_class*), so both
+must be supplied. The returned index can then be passed to other MPI tool
+information interface routines, such as :ref:`MPI_T_pvar_get_info`.
+
+This routine allows a tool to look up a performance variable by name without
+iterating over the entire set of performance variables. Because the number of
+performance variables exposed by the implementation can change over time, this
+is both more convenient and lower overhead than enumerating all of the
+variables to find a particular one.
+
+
+NOTES
+-----
+
+Performance variable names are implementation-specific. Looking a variable up
+by name is therefore not portable across MPI implementations, but may be the
+preferred approach for a tool that targets Open MPI specifically.
+
+
+ERRORS
+------
+
+:ref:`MPI_T_pvar_get_index` will fail if:
+
+* ``MPI_T_ERR_NOT_INITIALIZED``: The MPI Tools interface is not initialized.
+
+* ``MPI_T_ERR_INVALID``: ``name`` or ``pvar_index`` is ``NULL``.
+
+* ``MPI_T_ERR_INVALID_NAME``: ``name`` does not match the name of any
+  performance variable of the specified *var_class* provided by the
+  implementation at the time of the call.
+
+
+.. seealso::
+   * :ref:`MPI_T_pvar_get_info`
+   * :ref:`MPI_T_pvar_get_num`
diff --git a/docs/man-openmpi/man3/MPI_T_source_get_timestamp.3.rst b/docs/man-openmpi/man3/MPI_T_source_get_timestamp.3.rst
index d7d67bc32da..96c7d7a0b1a 100644
--- a/docs/man-openmpi/man3/MPI_T_source_get_timestamp.3.rst
+++ b/docs/man-openmpi/man3/MPI_T_source_get_timestamp.3.rst
@@ -22,7 +22,7 @@ OUTPUT PARAMETERS
 DESCRIPTION
 -----------
 
-:ref:`MPI_T_source_get_timestamp` returns the current timestamp from the specificed source.
+:ref:`MPI_T_source_get_timestamp` returns the current timestamp from the specified source.
 
 
 ERRORS
diff --git a/docs/man-openmpi/man3/MPI_Type_match_size.3.rst b/docs/man-openmpi/man3/MPI_Type_match_size.3.rst
index 5670845b7f4..fb36aab07b2 100644
--- a/docs/man-openmpi/man3/MPI_Type_match_size.3.rst
+++ b/docs/man-openmpi/man3/MPI_Type_match_size.3.rst
@@ -41,6 +41,25 @@ suitable datatype. In C use the sizeof builtin instead of :ref:`MPI_Sizeof`.
 It is erroneous to specify a size not supported by the compiler.
 
 
+NOTES
+-----
+
+In Open MPI, *typeclass* always refers to a Fortran numeric intrinsic
+type, and :ref:`MPI_Type_match_size` only ever returns an intrinsic
+Fortran predefined datatype (for example, ``MPI_REAL8``,
+``MPI_INTEGER4``, or ``MPI_COMPLEX8``) |mdash| regardless of whether it
+is called from C or Fortran. It does not return C predefined datatypes
+(such as ``MPI_DOUBLE``), nor composite predefined datatypes (such as
+``MPI_2REAL`` or ``MPI_2INTEGER``), even when one of those happens to
+have the requested *size*.
+
+Consequently, if Open MPI was built with ``--disable-mpi-fortran``, the
+Fortran intrinsic datatypes are unavailable. In that case no datatype
+can match any *typeclass* / *size* combination: every such request is
+treated as a size not supported by the compiler, and the call fails with
+error class ``MPI_ERR_ARG`` (subject to the relevant error handler).
+
+
 ERRORS
 ------
 
diff --git a/docs/man-openmpi/man3/MPI_Win_fence.3.rst b/docs/man-openmpi/man3/MPI_Win_fence.3.rst
index c37aa7433d8..90eb3a4fe06 100644
--- a/docs/man-openmpi/man3/MPI_Win_fence.3.rst
+++ b/docs/man-openmpi/man3/MPI_Win_fence.3.rst
@@ -60,7 +60,7 @@ MPI_MODE_NOSTORE
 
 MPI_MODE_NOPUT
    Informs that the local window will not be updated by any put or
-   accummulate calls in the ensuing epoch (until next fence call).
+   accumulate calls in the ensuing epoch (until next fence call).
 
 MPI_MODE_NOSUCCEED
    No local RMA calls will be issued after this fence. This assertion
diff --git a/docs/man-openmpi/man3/MPI_Win_post.3.rst b/docs/man-openmpi/man3/MPI_Win_post.3.rst
index fbbf122588a..53212ef02c6 100644
--- a/docs/man-openmpi/man3/MPI_Win_post.3.rst
+++ b/docs/man-openmpi/man3/MPI_Win_post.3.rst
@@ -46,7 +46,7 @@ MPI_MODE_NOSTORE
 
 MPI_MODE_NOPUT
    Informs that the local window will not be updated by put or
-   accummulate calls until the ensuing wait synchronization.
+   accumulate calls until the ensuing wait synchronization.
 
 
 ERRORS
diff --git a/docs/man-openmpi/man3/MPI_Win_set_info.3.rst b/docs/man-openmpi/man3/MPI_Win_set_info.3.rst
index 69de8bf2894..30aabb87f62 100644
--- a/docs/man-openmpi/man3/MPI_Win_set_info.3.rst
+++ b/docs/man-openmpi/man3/MPI_Win_set_info.3.rst
@@ -26,7 +26,7 @@ DESCRIPTION
 :ref:`MPI_WIN_SET_INFO` sets new values for the hints of the window associated
 with *win.* :ref:`MPI_WIN_SET_INFO` is a collective routine. The info object
 may be different on each process, but any info entries that an
-implementation requires to be the same on all processes must appear with
+implementation requires to have identical values on all processes must appear with
 the same value in each process's *info* object.
 
 
diff --git a/docs/man-openmpi/man3/MPI_Wtime.3.rst b/docs/man-openmpi/man3/MPI_Wtime.3.rst
index 9baeef4c46d..70edf333f3d 100644
--- a/docs/man-openmpi/man3/MPI_Wtime.3.rst
+++ b/docs/man-openmpi/man3/MPI_Wtime.3.rst
@@ -70,7 +70,7 @@ function will be used to obtain a monotonic clock value with whatever
 precision is supported on that platform (e.g., nanoseconds).
 
 Note, too, that the MCA parameter opal_timer_require_monotonic can
-influcence this behavior. It defaults to true, but if set to false, Open
+influence this behavior. It defaults to true, but if set to false, Open
 MPI may use a finer-grained timing mechanism (e.g., the RDTSC/RDTSCP
 clock ticks on x86_64 platforms), but is not guaranteed to be monotonic
 in some cases (e.g., if the MPI process is not bound to a single
diff --git a/docs/man-openmpi/man3/index.rst b/docs/man-openmpi/man3/index.rst
index c746815fbf3..2cbd07ad1d5 100644
--- a/docs/man-openmpi/man3/index.rst
+++ b/docs/man-openmpi/man3/index.rst
@@ -108,6 +108,7 @@ MPI API manual pages (section 3)
    MPI_Error_string.3.rst
    MPI_Exscan.3.rst
    MPI_Exscan_init.3.rst
+   MPI_F_sync_reg.3.rst
    MPI_Fetch_and_op.3.rst
    MPI_File_c2f.3.rst
    MPI_File_call_errhandler.3.rst
@@ -378,10 +379,12 @@ MPI API manual pages (section 3)
    MPI_T_category_get_categories.3.rst
    MPI_T_category_get_cvars.3.rst
    MPI_T_category_get_events.3.rst
+   MPI_T_category_get_index.3.rst
    MPI_T_category_get_info.3.rst
    MPI_T_category_get_num.3.rst
    MPI_T_category_get_num_events.3.rst
    MPI_T_category_get_pvars.3.rst
+   MPI_T_cvar_get_index.3.rst
    MPI_T_cvar_get_info.3.rst
    MPI_T_cvar_get_num.3.rst
    MPI_T_cvar_handle_alloc.3.rst
@@ -407,6 +410,7 @@ MPI API manual pages (section 3)
    MPI_T_event_set_dropped_handler.3.rst
    MPI_T_finalize.3.rst
    MPI_T_init_thread.3.rst
+   MPI_T_pvar_get_index.3.rst
    MPI_T_pvar_get_info.3.rst
    MPI_T_pvar_get_num.3.rst
    MPI_T_pvar_handle_alloc.3.rst
diff --git a/docs/man-openshmem/man3/shmem_int_fetch.3.rst b/docs/man-openshmem/man3/shmem_int_fetch.3.rst
index 29f8d0aaf31..ddb254b0bf8 100644
--- a/docs/man-openshmem/man3/shmem_int_fetch.3.rst
+++ b/docs/man-openshmem/man3/shmem_int_fetch.3.rst
@@ -75,7 +75,7 @@ RETURN VALUES
 -------------
 
 The contents at the *target* address on the remote PE. The data type of
-the return value is the same as the the type of the remote data object.
+the return value is the same as the type of the remote data object.
 
 
 .. seealso::
diff --git a/docs/man-openshmem/man3/shmem_wait.3.rst b/docs/man-openshmem/man3/shmem_wait.3.rst
index 5b5fd861e65..c30326bda2a 100644
--- a/docs/man-openshmem/man3/shmem_wait.3.rst
+++ b/docs/man-openshmem/man3/shmem_wait.3.rst
@@ -81,24 +81,6 @@ processor that it has completed some action.
 
 The arguments are as follows:
 
-target
-   The remotely accessible integer data object to be updated on the
-   remote PE. If you are using C/C++, the type of target should match
-   that implied in the SYNOPSIS section. If you are using the Fortran
-   compiler, it must be of type integer with an element size of 4 bytes
-   for SHMEM_INT4_ADD and 8 bytes for SHMEM_INT8_ADD.
-
-value
-   The value to be atomically added to target. If you are using C/C++,
-   the type of value should match that implied in the SYNOPSIS section.
-   If you are using Fortran, it must be of type integer with an element
-   size of target.
-
-pe
-   An integer that indicates the PE number upon which target is to be
-   updated. If you are using Fortran, it must be a default integer
-   value.
-
 ivar
    A remotely accessible integer variable that is being updated by
    another PE. If you are using C/C++, the type of ivar should match
@@ -139,7 +121,7 @@ cmp
 
 cmp_value
    cmp_value must be of type integer. If you are using C/C++, the type
-   of cmp_value should match thatimplied in the SYNOPSIS section. If you
+   of cmp_value should match that implied in the SYNOPSIS section. If you
    are using Fortran, cmp_value must be an integer of the same size and
    kind as ivar. The :ref:`shmem_wait` routines return when ivar is no longer
    equal to cmp_value. The :ref:`shmem_wait_until` routines return when the
diff --git a/docs/mca.rst b/docs/mca.rst
index 0c8256a4e55..9f2be8f009a 100644
--- a/docs/mca.rst
+++ b/docs/mca.rst
@@ -138,7 +138,7 @@ thumb that the developers use are:
 #. Instead of using a constant for an important value, make it an MCA
    parameter.
 #. If a task can be implemented in multiple, user-discernible ways,
-   implement as many as possible, and use an an MCA parameter to
+   implement as many as possible, and use an MCA parameter to
    choose between them at run-time.
 
 For example, an easy MCA parameter to describe is the boundary between
@@ -264,8 +264,6 @@ shells):
 Tuning MCA parameter files
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-.. error:: TODO This entire section needs to be checked for correctness.
-
 Simple text files can be used to set MCA parameter values for a
 specific application.
 
@@ -301,8 +299,9 @@ can be added to the command line as follows:
    shell$ mpirun -np 2 --tune foo.conf,bar.conf a.out
 
 The contents of tuned files consist of one or more lines, each of
-which contain zero or more `-x` and `--mca` options.  Comments are not
-allowed.  For example, the following tuned file:
+which contain zero or more ``-x`` and ``--mca`` options.  Empty lines
+and lines beginning with the ``#`` character are ignored.  For example,
+the following tuned file:
 
 .. code-block::
 
@@ -322,13 +321,11 @@ is equivalent to:
 
 Although the typical use case for tuned parameter files is to be
 specified on the command line, they can also be set as MCA parameters
-in the environment.  The MCA parameter ``mca_base_envvar_file_prefix``
+in the environment.  The MCA parameter ``mca_base_envar_file_prefix``
 contains a comma-delimited list of tuned parameter files exactly as
-they would be passed to the ``--tune`` command line option.  The MCA
-parameter ``mca_base_envvar_file_path`` specifies the path to search
-for tuned files with relative paths.
-
-.. error:: TODO Check that these MCA var names ^^ are correct.
+they would be passed to the ``--tune`` command line option.  Tuned
+files named with relative paths are resolved against the directories
+listed in the ``mca_base_param_file_path`` MCA parameter.
 
 Configuration files
 ^^^^^^^^^^^^^^^^^^^
@@ -361,9 +358,9 @@ By default, two files are searched (in order):
 #. ``$prefix/etc/openmpi-mca-params.conf``: The system-supplied set
    of values has a lower precedence.
 
-More specifically, the MCA parameter ``mca_param_files`` specifies a
-colon-delimited path of files to search for MCA parameters.  Files to
-the left have lower precedence; files to the right are higher
+More specifically, the MCA parameter ``mca_base_param_files`` specifies
+a comma-delimited list of files to search for MCA parameters.  Files to
+the left have *higher* precedence; files to the right have lower
 precedence.
 
 .. note:: Keep in mind that, just like components, these parameter
@@ -379,8 +376,6 @@ precedence.
           customization, which is especially relevant in heterogeneous
           environments.
 
-.. error:: TODO This table needs to be checked for correctness.
-
 .. warning:: Setting Open MPI MCA parameters via configuration files
              entails editing (by default) the ``mca-params.conf`` or
              ``openmpi-mca-params.conf`` files.  When setting PMIx-
@@ -392,12 +387,23 @@ precedence.
              |          | ``$prefix/etc/openmpi-mca-params.conf``  |
              +----------+------------------------------------------+
              | PMIx     | ``$HOME/.pmix/mca-params.conf`` or       |
-             |          | ``$prefix/etc/openpmix-mca-params.conf`` |
+             |          | ``$prefix/etc/pmix-mca-params.conf``     |
              +----------+------------------------------------------+
-             | PRRTE    | ``$HOME/.prrte/mca-params.conf`` or      |
+             | PRRTE    | ``$HOME/.prte/mca-params.conf`` or       |
              |          | ``$prefix/etc/prte-mca-params.conf``     |
              +----------+------------------------------------------+
 
+.. note:: By default, PRRTE and PMIx read only their own configuration
+          files (the PMIx and PRRTE rows above), not Open MPI's
+          ``openmpi-mca-params.conf``.  If you set the ``OMPIHOME``
+          environment variable, however, the runtime will additionally
+          read ``$OMPIHOME/etc/openmpi-mca-params.conf`` and apply any
+          PRRTE- and PMIx-related MCA parameters it finds there.  This
+          is a convenient way to keep the PRRTE and PMIx settings for a
+          given Open MPI installation alongside the Open MPI settings in
+          a single file.  Values already set in the environment take
+          precedence and are not overwritten.
+
 /////////////////////////////////////////////////////////////////////////
 
 .. _label-running-displaying-mca-param-values:
@@ -463,7 +469,7 @@ instead of being printed to stdout.  For example:
 .. code-block:: sh
 
    shell$ mpirun --mca mpi_show_mca_params enviro \
-       --mca mpi_show_mca_param_file /tmp/foo.txt hello_c
+       --mca mpi_show_mca_params_file /tmp/foo.txt hello_c
    Hello, World, I am 0 of 1
    shell$ cat /tmp/foo.txt
    #
@@ -667,23 +673,31 @@ MCA Parameter Changes Between Open MPI 4.x and newer releases
 When Open MPI :ref:`switched from using ORTE to PRRTE as its run-time
 environment, <label-running-role-of-pmix-and-prte>` some MCA
 parameters were renamed to be more consistent and/or allow more
-flexible behavior.  The deprecated Open MPI MCA parameters listed
-below are currently replaced by a corresponding new PRRTE parameter,
-but may be removed in future releases.
-
-.. note:: In all cases listed below, the deprecated MCA parameter is
-          an Open MPI MCA parameter, meaning that its corresponding
-          environment variable was prefixed with ``OMPI_MCA_`` (e.g.,
-          ``OMPI_MCA_orte_xml_output``).  However, the corresponding
-          new MCA parameter is a PRRTE MCA parameter, meaning that its
-          corresponding environment variable is prefixed with
-          ``PRTE_MCA_`` (e.g., ``PRTE_MCA_output``).
+flexible behavior.  The Open MPI (ORTE-era) MCA parameters in the left column below no
+longer exist; use the corresponding replacement shown in the right
+column.
+
+.. note:: The old MCA parameters in the left column were Open MPI
+          parameters, meaning that their corresponding environment
+          variables were prefixed with ``OMPI_MCA_`` (e.g.,
+          ``OMPI_MCA_orte_xml_output``).  Most of their replacements are
+          PRRTE parameters, meaning that their corresponding environment
+          variables are prefixed with ``PRTE_MCA_`` (e.g.,
+          ``PRTE_MCA_output``).  The one exception is
+          ``ompi_stream_buffering``, which remains an Open MPI parameter
+          (``OMPI_MCA_ompi_stream_buffering``).
 
           .. important:: Yes, that's a single ``R`` in the
                          ``PRTE_MCA_`` environment variable prefix.
                          `See this explanation
-                         <https://docs.prrte.org/>`_ for the when one
-                         R or two R's are used in the PRRTE name.
+                         <https://docs.prrte.org/>`_ for when one R or
+                         two R's are used in the PRRTE name.
+
+.. note:: ``mapby`` and ``bindto`` are the current names for these two
+          parameters.  The older ``rmaps_default_mapping_policy`` and
+          ``hwloc_default_binding_policy`` names still work as deprecated
+          synonyms, but new configurations should use ``mapby`` and
+          ``bindto``.
 
 
 .. list-table::
@@ -788,7 +802,7 @@ but may be removed in future releases.
       - ``rmaps_base_no_schedule_local``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``[<mapping>]:nolocal``
 
@@ -797,7 +811,7 @@ but may be removed in future releases.
       - ``rmaps_base_oversubscribe``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``[<mapping>]:oversubscribe``
 
@@ -806,7 +820,7 @@ but may be removed in future releases.
       - ``rmaps_base_no_oversubscribe``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``[<mapping>]:nooversubscribe``
 
@@ -814,7 +828,7 @@ but may be removed in future releases.
       - ``hwloc_base_use_hwthreads_as_cpus``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``[<mapping>]:hwtcpus``
 
@@ -823,23 +837,23 @@ but may be removed in future releases.
       - ``hwloc_base_cpu_set``
 
         Value: ``<value>``
-      - ``rmaps_default_mapping_policy``
+      - ``hwloc_default_cpu_list``
 
-        Value: ``pe-list=<value>``
+        Value: ``<value>``
 
     * - List of processor IDs to bind processes to
       - ``hwloc_base_cpu_list``
 
         Value: ``<value>``
-      - ``rmaps_default_mapping_policy``
+      - ``hwloc_default_cpu_list``
 
-        Value: ``pe-list=<value>``
+        Value: ``<value>``
 
     * - Bind processes to cores
       - ``hwloc_base_bind_to_core``
 
         Values: boolean
-      - ``hwloc_default_binding_policy``
+      - ``bindto``
 
         Value: ``core``
 
@@ -847,7 +861,7 @@ but may be removed in future releases.
       - ``hwloc_base_bind_to_socket``
 
         Values: boolean
-      - ``hwloc_default_binding_policy``
+      - ``bindto``
 
         Value: ``package``
 
@@ -855,7 +869,7 @@ but may be removed in future releases.
       - ``rmaps_base_bynode``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``node``
 
@@ -863,7 +877,7 @@ but may be removed in future releases.
       - ``rmaps_base_bycore``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``core``
 
@@ -871,7 +885,7 @@ but may be removed in future releases.
       - ``rmaps_base_byslot``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``slot``
 
@@ -879,7 +893,7 @@ but may be removed in future releases.
       - ``rmaps_base_cpus_per_rank``
 
         Value: ``<X>``
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``[<mapping>]:pe=<X>``
 
@@ -887,7 +901,7 @@ but may be removed in future releases.
       - ``rmaps_ppr_n_pernode``
 
         Value: ``<X>``
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``ppr:<X>:node``
 
@@ -895,7 +909,7 @@ but may be removed in future releases.
       - ``rmaps_ppr_pernode``
 
         Values: boolean
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``ppr:1:node``
 
@@ -903,7 +917,7 @@ but may be removed in future releases.
       - ``rmaps_ppr_n_persocket``
 
         Value: integer ``<X>``
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``ppr:<X>:package``
 
@@ -912,7 +926,7 @@ but may be removed in future releases.
       - ``rmaps_ppr_pattern``
 
         Value: ``<value>``
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``ppr:<value>``
 
@@ -920,7 +934,7 @@ but may be removed in future releases.
       - ``orte_rankfile``
 
         Value: ``<filename>``
-      - ``rmaps_default_mapping_policy``
+      - ``mapby``
 
         Value: ``rankfile:file=<filename>``
 
@@ -942,7 +956,7 @@ Simple values, where only the name of the MCA parameter changed
    export OMPI_MCA_orte_ess_base_stream_buffering=2
 
    # New environment variable: (integer value)
-   export PRTE_MCA_ompi_stream_buffering=2
+   export OMPI_MCA_ompi_stream_buffering=2
 
 .. code-block:: ini
 
@@ -1037,7 +1051,7 @@ Converting mapping parameters
 
 Mapping parameters were previously prefixed with ``rmaps_base_`` or ``hwloc_base_``
 (and also the ``orte_rankfile`` parameter).  These have been updated
-to the ``rmaps_default_mapping_policy`` and ``hwloc_default_binding_policy``
+to the ``mapby`` and ``bindto``
 parameters to be more consistent and indicate that they are the *default*
 mapping for processes.  Some of the old parameters are now values for a
 new parameter and some are now suffixes, as shown in the examples below.
@@ -1051,7 +1065,7 @@ parameter values:
    export OMPI_MCA_rmaps_base_bycore=1
 
    # New environment variable: (parameter value)
-   export PRTE_MCA_rmaps_default_mapping_policy=core
+   export PRTE_MCA_mapby=core
 
 .. code-block:: ini
 
@@ -1059,7 +1073,7 @@ parameter values:
    export OMPI_MCA_hwloc_base_bind_to_socket=1
 
    # New environment variable: (parameter value)
-   export PRTE_MCA_hwloc_default_binding_policy=package
+   export PRTE_MCA_bindto=package
 
 
 The examples below show conversions from old parameters that have integer or
@@ -1071,7 +1085,7 @@ string values to new parameter values with those same values:
    export OMPI_MCA_hwloc_base_cpu_set=1,3,8
 
    # New environment variable: (parameter value)
-   export PRTE_MCA_rmaps_default_mapping_policy=pe-list=1,3,8
+   export PRTE_MCA_hwloc_default_cpu_list=1,3,8
 
 .. code-block:: ini
 
@@ -1079,7 +1093,7 @@ string values to new parameter values with those same values:
    export OMPI_MCA_rmaps_ppr_n_persocket=4
 
    # New environment variable: (parameter value)
-   export PRTE_MCA_rmaps_default_mapping_policy=ppr:4:package
+   export PRTE_MCA_mapby=ppr:4:package
 
 .. code-block:: ini
 
@@ -1087,7 +1101,7 @@ string values to new parameter values with those same values:
    export OMPI_MCA_orte_rankfile=rankfile.txt
 
    # New environment variable: (parameter value)
-   export PRTE_MCA_rmaps_default_mapping_policy=rankfile:file=rankfile.txt
+   export PRTE_MCA_mapby=rankfile:file=rankfile.txt
 
 The examples below show conversions from old parameters that map to suffixes
 for new parameter values:
@@ -1098,7 +1112,7 @@ for new parameter values:
    export OMPI_MCA_hwloc_base_use_hwthreads_as_cpus=1
 
    # New environment variable: (standalone suffix)
-   export PRTE_MCA_rmaps_default_mapping_policy=:hwtcpus
+   export PRTE_MCA_mapby=:hwtcpus
 
 .. code-block:: ini
 
@@ -1106,7 +1120,7 @@ for new parameter values:
    export OMPI_MCA_rmaps_base_oversubscribe=1
 
    # New environment variable: (standalone suffix)
-   export PRTE_MCA_rmaps_default_mapping_policy=:oversubscribe
+   export PRTE_MCA_mapby=:oversubscribe
 
 The examples below show conversions from old parameters that map to suffixes
 combined with parameters that have values:
@@ -1119,8 +1133,29 @@ combined with parameters that have values:
    # Old environment variable: (boolean value)
    export OMPI_MCA_rmaps_base_oversubscribe=1
 
-   # New environment variable: (suffix on value)
-   export PRTE_MCA_rmaps_default_mapping_policy=pe-list=1,3,8:oversubscribe
+   # New environment variables: (separate parameters)
+   export PRTE_MCA_hwloc_default_cpu_list=1,3,8
+   export PRTE_MCA_mapby=:oversubscribe
+
+.. note:: ``hwloc_default_cpu_list`` restricts the set of CPUs that
+          PRRTE may use; it does not bind each process to all of the
+          listed CPUs.  With the default mapping and binding policies,
+          the example above therefore places one process on CPU 1, one
+          on CPU 3, and one on CPU 8, each bound to just that one CPU.
+
+          To bind each process to *all* of the listed CPUs, use the
+          ``pe-list`` mapping directive instead:
+
+          .. code-block:: sh
+
+             shell$ mpirun --map-by pe-list=1,3,8:oversubscribe ...
+
+          Adding the ``ordered`` qualifier (``--map-by
+          pe-list=1,3,8:ordered:oversubscribe``) yields the
+          one-process-per-listed-CPU placement described above.  Note
+          that ``pe-list`` is only accepted on the command line; PRRTE
+          rejects it as a default mapping policy (i.e., as the value
+          of the ``mapby`` MCA parameter).
 
 .. code-block:: ini
 
@@ -1131,7 +1166,7 @@ combined with parameters that have values:
    export OMPI_MCA_hwloc_base_use_hwthreads_as_cpus=1
 
    # New environment variable: (suffix on value)
-   export PRTE_MCA_rmaps_default_mapping_policy=ppr:4:package:hwtcpus
+   export PRTE_MCA_mapby=ppr:4:package:hwtcpus
 
 Multiple suffixes may be appended to a mapping value:
 
@@ -1145,4 +1180,4 @@ Multiple suffixes may be appended to a mapping value:
    export OMPI_MCA_rmaps_base_oversubscribe=1
 
    # New environment variable: (suffix on value)
-   export PRTE_MCA_rmaps_default_mapping_policy=ppr:4:package:hwtcpus:oversubscribe
+   export PRTE_MCA_mapby=ppr:4:package:hwtcpus:oversubscribe
diff --git a/docs/ompi_docs_common.py b/docs/ompi_docs_common.py
new file mode 100644
index 00000000000..4f8b8650113
--- /dev/null
+++ b/docs/ompi_docs_common.py
@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2026 Jeffrey M. Squyres.  All rights reserved.
+#
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+"""Shared MPI documentation metadata helpers.
+
+This module factors out logic that is common to the Open MPI
+documentation generators:
+
+* ``docs/generate-mpi-man3-bindings.py`` (the human man-page bindings), and
+* ``docs/generate-llm-docs.py`` (the LLM-friendly artifacts).
+
+It provides:
+
+* parsing of the top-level ``VERSION`` file (without importing
+  ``docs/conf.py``, which would trigger Sphinx configuration side effects);
+* loading of the embedded ``pympistandard`` library plus
+  ``docs/mpi-standard-apis.json``;
+* parsing of the ``.. mpi-bindings:`` man-page directives that mark pages
+  documenting multiple MPI procedures;
+* rendering of the C (``iso_c``), fixed-form Fortran (``f90``), and
+  ``use mpi_f08`` (``f08``) binding strings, including the large-count
+  ("embiggened") variants; and
+* build-identity helpers (git commit / ``git describe``) and a
+  ``SOURCE_DATE_EPOCH``-aware UTC timestamp.
+
+All code here must remain compatible with Open MPI's supported Python
+version floor (see ``python_min_version`` in the top-level ``VERSION``
+file): Python 3.6.
+"""
+
+import os
+import re
+import subprocess
+import sys
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+# ---------------------------------------------------------------------------
+# VERSION file parsing
+# ---------------------------------------------------------------------------
+
+def read_version_file(path):
+    """Parse an Open MPI-style VERSION file into a dict.
+
+    Uses the same rules as ``docs/conf.py`` (strip ``#`` comments, keep
+    ``key=value`` lines), but does not import ``conf.py`` so that no Sphinx
+    configuration side effects are triggered.
+    """
+    if not os.path.exists(path):
+        raise FileNotFoundError("Unable to find VERSION file {}".format(path))
+
+    data = {}
+    with open(path, encoding='utf-8') as fp:
+        for line in fp.readlines():
+            if '#' in line:
+                line = line.split("#")[0]
+            line = line.strip()
+            if '=' not in line:
+                continue
+            key, val = line.split("=", 1)
+            data[key.strip()] = val.strip()
+    return data
+
+
+def ompi_version_info(top_srcdir):
+    """Return a dict of assembled Open MPI version strings.
+
+    ``top_srcdir`` is the top of the Open MPI source tree (the directory
+    that contains the ``VERSION`` file). The returned dict includes:
+
+    * ``ompi_version``: e.g. ``v6.1.0a1``
+    * ``ompi_series``:  e.g. ``v6.1.x``
+    * ``mpi_standard_version``: e.g. ``4.1``
+    """
+    data = read_version_file(os.path.join(top_srcdir, "VERSION"))
+    major = data["major"]
+    minor = data["minor"]
+    release = data["release"]
+    greek = data.get("greek", "")
+    info = {
+        "major": major,
+        "minor": minor,
+        "release": release,
+        "greek": greek,
+        "ompi_version": "v{}.{}.{}{}".format(major, minor, release, greek),
+        "ompi_series": "v{}.{}.x".format(major, minor),
+    }
+    if "mpi_standard_version" in data and "mpi_standard_subversion" in data:
+        info["mpi_standard_version"] = "{}.{}".format(
+            data["mpi_standard_version"], data["mpi_standard_subversion"])
+        info["mpi_standard_major_version"] = data["mpi_standard_version"]
+        info["mpi_standard_minor_version"] = data["mpi_standard_subversion"]
+    info["python_min_version"] = data.get("python_min_version")
+    return info
+
+
+# ---------------------------------------------------------------------------
+# pympistandard loading
+# ---------------------------------------------------------------------------
+
+def load_pympistandard(docs_srcdir):
+    """Import and initialize the embedded ``pympistandard`` library.
+
+    ``docs_srcdir`` is the ``docs/`` source directory. The ``pympistandard``
+    package lives in the Open MPI ``3rd-party`` tree, and the MPI Standard
+    API JSON ships as ``docs/mpi-standard-apis.json`` (see
+    ``generate-mpi-man3-bindings.py`` for provenance).
+
+    Returns the imported ``pympistandard`` module, already initialized with
+    ``use_api_version(1, ...)``.
+    """
+    docs_srcdir = os.path.abspath(docs_srcdir)
+    top_srcdir = os.path.dirname(docs_srcdir)
+
+    pympistandard_dir = Path(os.path.join(
+        top_srcdir, "3rd-party", "pympistandard", "src")).resolve()
+    sys.path.insert(0, str(pympistandard_dir))
+
+    import pympistandard as std
+
+    mpi_standard_json = os.path.join(docs_srcdir, "mpi-standard-apis.json")
+    std.use_api_version(1, given_path=mpi_standard_json)
+    return std
+
+
+# ---------------------------------------------------------------------------
+# .. mpi-bindings: directive parsing
+# ---------------------------------------------------------------------------
+
+def read_rst_man_pages(src_dir):
+    """Scan ``src_dir/man-openmpi/man3`` for ``.. mpi-bindings:`` directives.
+
+    Some ``MPI_*.3.rst`` man pages document several MPI procedures via a
+    ``.. mpi-bindings: MPI_Foo, MPI_Bar`` comment line (a single-colon
+    comment, not a registered Sphinx directive). Returns a dict mapping each
+    man-page API name (lowercased, without ``.3.rst``) to the list of
+    lowercased procedure names documented on that page.
+    """
+    directives = {}
+    prog = re.compile(r'^MPI_.*\.3\.rst$')
+
+    man3_dir = Path(os.path.join(src_dir, 'man-openmpi', 'man3')).resolve()
+    for file in os.listdir(man3_dir):
+        if not prog.match(file):
+            continue
+
+        with open(os.path.join(man3_dir, file), encoding='utf-8') as fp:
+            lines = fp.readlines()
+
+        file_api_name = file.replace('.3.rst', '').lower()
+        directives[file_api_name] = list()
+
+        prefix = '.. mpi-bindings:'
+        for line in lines:
+            line = line.strip()
+            if not line.startswith(prefix):
+                continue
+
+            bindings = line[len(prefix):].split(',')
+            for binding in bindings:
+                binding = binding.strip()
+                directives[file_api_name].append(binding.lower())
+
+    return directives
+
+
+# ---------------------------------------------------------------------------
+# Binding string rendering
+# ---------------------------------------------------------------------------
+
+def _valid_binding(binding):
+    """An express binding is usable iff it is a non-empty, non-'None' string."""
+    return binding is not None and len(binding) > 0 and binding != 'None'
+
+
+def c_binding(data):
+    """Return the C (``iso_c``) binding string for a procedure, or ``None``.
+
+    Applies the workaround for
+    https://github.com/mpi-forum/pympistandard/issues/25, where
+    ``MPI_Pcontrol`` renders ``\\ldots`` instead of ``...``.
+    """
+    binding = str(data.express.iso_c)
+    if not _valid_binding(binding):
+        return None
+    return binding.replace(r'\ldots', '...')
+
+
+def c_binding_large(data):
+    """Return the large-count C binding string, or ``None`` if none exists."""
+    if not data.has_embiggenment():
+        return None
+    binding = str(data.express.embiggen.iso_c)
+    if not _valid_binding(binding):
+        return None
+    return binding.replace(r'\ldots', '...')
+
+
+def f90_binding(data):
+    """Return the fixed-form Fortran (``f90``) binding string, or ``None``.
+
+    The same string is used for both the ``mpif.h`` and ``use mpi``
+    interfaces; they differ only in how the interface is accessed
+    (``INCLUDE 'mpif.h'`` versus ``USE mpi``), not in the signature.
+    """
+    binding = str(data.express.f90)
+    if not _valid_binding(binding):
+        return None
+    return binding
+
+
+def f08_binding(data):
+    """Return the ``use mpi_f08`` (``f08``) binding string, or ``None``."""
+    binding = str(data.express.f08)
+    if not _valid_binding(binding):
+        return None
+    return binding
+
+
+def f08_binding_large(data):
+    """Return the large-count ``f08`` binding string, or ``None``."""
+    if not data.has_embiggenment():
+        return None
+    binding = str(data.express.embiggen.f08)
+    if not _valid_binding(binding):
+        return None
+    return binding
+
+
+# ---------------------------------------------------------------------------
+# Build identity / reproducible timestamp
+# ---------------------------------------------------------------------------
+
+def _git(top_srcdir, args):
+    """Run a git command in ``top_srcdir``; return stripped stdout or None."""
+    try:
+        out = subprocess.check_output(
+            ['git'] + args, cwd=top_srcdir, stderr=subprocess.DEVNULL)
+    except (OSError, subprocess.CalledProcessError):
+        return None
+    out = out.decode('utf-8', 'replace').strip()
+    return out if out else None
+
+
+def git_commit(top_srcdir):
+    """Return the full source commit hash, or ``None`` if unavailable."""
+    return _git(top_srcdir, ['rev-parse', 'HEAD'])
+
+
+def git_describe(top_srcdir):
+    """Return ``git describe --tags --always`` output, or ``None``.
+
+    Mirrors how ``config/opal_get_version.sh`` resolves the repo revision.
+    """
+    return _git(top_srcdir, ['describe', '--tags', '--always'])
+
+
+def source_date_epoch():
+    """Return the reproducible build epoch (int seconds) honored project-wide.
+
+    Honors ``SOURCE_DATE_EPOCH`` (see https://reproducible-builds.org/ and
+    ``config/getdate.sh``); returns ``None`` if it is unset or unparsable so
+    the caller can fall back gracefully (e.g. to a git commit date).
+    """
+    raw = os.environ.get('SOURCE_DATE_EPOCH')
+    if raw is None:
+        return None
+    try:
+        return int(raw)
+    except ValueError:
+        return None
+
+
+def generated_at_utc(top_srcdir=None):
+    """Return an ISO-8601 UTC timestamp string for artifact generation.
+
+    Resolution order, mirroring the rest of the build:
+
+    1. ``SOURCE_DATE_EPOCH`` if set (reproducible builds);
+    2. the build commit's committer date, if a git checkout is available;
+    3. the current wall-clock time.
+    """
+    epoch = source_date_epoch()
+    if epoch is None and top_srcdir is not None:
+        commit_epoch = _git(top_srcdir, ['log', '-1', '--format=%ct'])
+        if commit_epoch is not None:
+            try:
+                epoch = int(commit_epoch)
+            except ValueError:
+                epoch = None
+    if epoch is not None:
+        dt = datetime.fromtimestamp(epoch, tz=timezone.utc)
+    else:
+        dt = datetime.now(tz=timezone.utc)
+    return dt.strftime('%Y-%m-%dT%H:%M:%SZ')
diff --git a/docs/release-notes/changelog/index.rst b/docs/release-notes/changelog/index.rst
index 18dbd073f8d..420b55c91c5 100644
--- a/docs/release-notes/changelog/index.rst
+++ b/docs/release-notes/changelog/index.rst
@@ -8,6 +8,7 @@ since v1.0.0.
 .. toctree::
    :maxdepth: 1
 
+   v6.1.x
    v6.0.x
    v5.0.x
    v4.1.x
diff --git a/docs/release-notes/changelog/v1.x.rst b/docs/release-notes/changelog/v1.x.rst
index b945177598c..a6180d0a1d3 100644
--- a/docs/release-notes/changelog/v1.x.rst
+++ b/docs/release-notes/changelog/v1.x.rst
@@ -14,7 +14,7 @@ Open MPI version 1.10.7
 - Fix bug in TCP BTL that impacted performance on 10GbE (and faster)
   networks by not adjusting the TCP send/recv buffer sizes and using
   system default values
-- Add missing MPI_AINT_ADD and MPI_AINT_DIFF function delcarations in
+- Add missing MPI_AINT_ADD and MPI_AINT_DIFF function declarations in
   mpif.h
 - Fixed time reported by MPI_WTIME; it was previously reported as
   dependent upon the CPU frequency.
@@ -340,7 +340,7 @@ Open MPI version 1.10.0
 - Fixed a variety of small bugs in OpenSHMEM.
 - Fixed MXM configure with additional CPPFLAGS and LDFLAGS.  Thanks to
   David Shrader for the patch.
-- Fixed incorrect memalign threshhold in the openib BTL.  Thanks to
+- Fixed incorrect memalign threshold in the openib BTL.  Thanks to
   Xavier Besseron for pointing out the issue.
 
 
@@ -503,7 +503,7 @@ Open MPI version 1.8.4
 - Fix MPI_SIZEOF; now available in mpif.h for modern Fortran compilers
   (see README for more details).  Also fixed various compiler/linker
   errors.
-- Fixed inadvertant Fortran ABI break between v1.8.1 and v1.8.2 in the
+- Fixed inadvertent Fortran ABI break between v1.8.1 and v1.8.2 in the
   mpi interface module when compiled with gfortran >= v4.9.
 - Fix various MPI_THREAD_MULTIPLE issues in the TCP BTL.
 - mpirun no longer requires the ``--hetero-nodes`` switch; it will
@@ -694,7 +694,7 @@ Open MPI version 1.7.5
 - Fix MPI_GRAPH_CREATE when nnodes is smaller than the size of the old
   communicator.
 - usnic BTL now supports underlying UDP transport.
-- usnic BTL now checks for common connectivty errors at first send to
+- usnic BTL now checks for common connectivity errors at first send to
   a remote server.
 - Minor scalability improvements in the usnic BTL.
 - ompi_info now lists whether the Java MPI bindings are available or not.
@@ -782,7 +782,7 @@ Open MPI version 1.7.4
 - Prevent integer overflow when creating datatypes.  Thanks to
   original patch from Gilles Gouaillardet.
 - Port some upstream hwloc fixes to Open MPI's embedded copy for
-  working around buggy NUMA node cpusets and including mising header
+  working around buggy NUMA node cpusets and including missing header
   files.  Thanks to Jeff Becker and Paul Hargrove for reporting the
   issues.
 - Fix recursive invocation issues in the MXM MTL.
@@ -1060,7 +1060,7 @@ Open MPI version 1.7.0
   MCA params).
 - Upgraded to hwloc v1.5.1.
 - Added performance improvements to the OpenIB (OpenFabrics) BTL.
-- Made malloc hooks more friendly to IO interprosers.  Thanks to the
+- Made malloc hooks more friendly to IO interposers.  Thanks to the
   bug report and suggested fix from Darshan maintainer Phil Carns.
 - Added support for the DMTCP checkpoint/restart system.
 - Added support for the Cray uGNI interconnect.
@@ -1217,7 +1217,7 @@ Open MPI version 1.6.4
 - Improved error message when process affinity fails.
 - Fixed MPI_MINLOC on man pages for MPI_REDUCE(_LOCAL).  Thanks to Jed
   Brown for noticing the problem and supplying a fix.
-- Made malloc hooks more friendly to IO interprosers.  Thanks to the
+- Made malloc hooks more friendly to IO interposers.  Thanks to the
   bug report and suggested fix from Darshan maintainer Phil Carns.
 - Restored ability to direct launch under SLURM without PMI support.
 - Fixed MPI datatype issues on OpenBSD.
@@ -1296,7 +1296,7 @@ Open MPI version 1.6.1
   https://www.open-mpi.org/faq/?category=openfabrics#ib-low-reg-mem
 
    - Fall back to send/receive semantics if registered memory is
-     unavilable for RDMA.
+     unavailable for RDMA.
    - Fix two fragment leaks when registered memory is exhausted.
    - Hueristically determine how much registered memory is available
      and warn if it's significantly less than all of RAM.
@@ -1317,7 +1317,7 @@ Open MPI version 1.6.1
   OpenFabrics devices.
 - Lots of VampirTrace fixes; upgrade to v5.13.0.4.
 - Map MPI_2INTEGER to underlying MPI_INTEGERs, not MPI_INTs.
-- Ensure that the OMPI version number is toleant of handling spaces.
+- Ensure that the OMPI version number is tolerant of handling spaces.
   Thanks to dragonboy for identifying the issue.
 - Fixed IN parameter marking on Fortran "mpi" module
   MPI_COMM_TEST_INTER interface.
@@ -1810,7 +1810,7 @@ Open MPI version 1.4.4
   to Avinash Malik for reporting the issue.
 - Fix for correctly handling multi-token args when using debuggers.
 - Eliminated the unneeded ``u_int*_t`` datatype definitions.
-- Change in ORTE DPM to get around gcc 4.[45].x compiler wanrings
+- Change in ORTE DPM to get around gcc 4.[45].x compiler warnings
   about possibly calling free() on a non-heap variable, even though it
   will never happen because the refcount will never go to zero.
 - Fixed incorrect text in MPI_File_set_view man page.
@@ -1889,7 +1889,7 @@ Open MPI version 1.4.3
 - Change to ensure TotalView works properly on Darwin.
 - Added support for Visual Studio 2010.
 - Fix to ensure proper placement of VampirTrace header files.
-- Needed to add volatile keyword to a varialbe used in debugging
+- Needed to add volatile keyword to a variable used in debugging
   (MPIR_being_debugged).
 - Fixed a bug in inter-allgather.
 - Fixed malloc(0) warnings.
@@ -2275,7 +2275,7 @@ Open MPI version 1.3.0
 
    - Added ``btl_openib_if_[in|ex]clude`` MCA parameters for
      including/excluding comma-delimited lists of HCAs and ports.
-   - Added RDMA CM support, includng ``btl_openib_cpc_[in|ex]clude``
+   - Added RDMA CM support, including ``btl_openib_cpc_[in|ex]clude``
      MCA parameters
    - Added NUMA support to only use "near" network adapters
    - Added "Bucket SRQ" (BSRQ) support to better utilize registered
@@ -2283,7 +2283,7 @@ Open MPI version 1.3.0
    - Added ConnectX XRC support (and integrated with BSRQ)
    - Added btl_openib_ib_max_inline_data MCA parameter
    - Added iWARP support
-   - Revamped flow control mechansisms to be more efficient
+   - Revamped flow control mechanisms to be more efficient
    - ``mpi_leave_pinned=1`` is now the default when possible,
      automatically improving performance for large messages when
      application buffers are re-used
@@ -2305,7 +2305,7 @@ Open MPI version 1.3.0
   predefined datatypes in the fortran header files, there will not be
   any compatibility issues.
 - Added Portable Linux Processor Affinity (PLPA) for Linux.
-- Addition of a finer symbols export control via the visibiliy feature
+- Addition of a finer symbols export control via the visibility feature
   offered by some compilers.
 - Added checkpoint/restart process fault tolerance support. Initially
   support a LAM/MPI-like protocol.
@@ -2318,7 +2318,7 @@ Open MPI version 1.3.0
   use leave_pinned with ptmalloc2 will now need to link the library
   into their application explicitly.  All other users will use the
   libc-provided allocator instead of Open MPI's ptmalloc2.  This change
-  may be overriden with the configure option enable-ptmalloc2-internal
+  may be overridden with the configure option enable-ptmalloc2-internal
 - The leave_pinned options will now default to using mallopt on
   Linux in the cases where ptmalloc2 was not linked in.  mallopt
   will also only be available if munmap can be intercepted (the
@@ -2355,7 +2355,7 @@ Open MPI version 1.2.9
 - Fix the ``--enable-cxx-exceptions`` configure option. See ticket #1607.
 - Properly handle when the MX BTL cannot open an endpoint. See ticket #1621.
 - Fix a double free of events on the tcp_events list. See ticket #1631.
-- Fix a buffer overun in opal_free_list_grow (called by MPI_Init).
+- Fix a buffer overrun in opal_free_list_grow (called by MPI_Init).
   Thanks to Patrick Farrell for the bugreport and Stephan Kramer for
   the bugfix.  See ticket #1583.
 - Fix a problem setting OPAL_PREFIX for remote sh-based shells.
@@ -2824,7 +2824,7 @@ Open MPI version 1.1.2
 - Fix receiving messages to buffers allocated by MPI_ALLOC_MEM.
 - Fix a number of race conditions with the MPI-2 Onesided
   interface.
-- Fix the "tuned" collective componenete where some cases where
+- Fix the "tuned" collective component where some cases where
   MPI_BCAST could hang.
 - Update TCP support to support non-uniform TCP environments.
 - Allow the "poe" RAS component to be built on AIX or Linux.
@@ -2841,7 +2841,7 @@ Open MPI version 1.1.1
 - Fix for Fortran string handling in various MPI API functions.
 - Fix for Fortran status handling in MPI_WAITSOME and MPI_TESTSOME.
 - Various fixes for the XL compilers.
-- Automatically disable using mallot() on AIX.
+- Automatically disable using mallopt() on AIX.
 - Memory fixes for 64 bit platforms with registering MCA parameters in
   the self and MX BTL components.
 - Fixes for BProc to support oversubscription and changes to the
@@ -2919,7 +2919,7 @@ Open MPI version 1.1.0
      match.  Thanks to Michael Kluskens for pointing out the problems
      to us.
 
-- Allow short messagees to use RDMA (vs. send/receive semantics) to a
+- Allow short messages to use RDMA (vs. send/receive semantics) to a
   limited number peers in both the mvapi and openib BTL components.
   This reduces communication latency over IB channels.
 - Numerous performance improvements throughout the entire code base.
@@ -3143,7 +3143,7 @@ Open MPI version 1.0.1
   MPI_SCATTERV implementation.
 - Fix EOF handling on stdin.
 - Fix missing MPI_F_STATUS_IGNORE and MPI_F_STATUSES_IGNORE
-  instanatiations.  Thanks to Anthony Chan for pointing this out.
+  instantiations.  Thanks to Anthony Chan for pointing this out.
 - Add a missing value for MPI_WIN_NULL in mpif.h.
 - Bring over some fixes for the sm btl that somehow didn't make it
   over from the trunk before v1.0.  Thanks to Beth Tibbitts and Bill
diff --git a/docs/release-notes/changelog/v2.x.rst b/docs/release-notes/changelog/v2.x.rst
index 896055a43b6..13995071739 100644
--- a/docs/release-notes/changelog/v2.x.rst
+++ b/docs/release-notes/changelog/v2.x.rst
@@ -220,8 +220,8 @@ Open MPI version 2.1.0
 .. attention:: Removed legacy support:
 
    - The ptmalloc2 hooks have been removed from the Open MPI code base.
-     This is not really a user-noticable change; it is only mentioned
-     here because there was much rejoycing in the Open MPI developer
+     This is not really a user-noticeable change; it is only mentioned
+     here because there was much rejoicing in the Open MPI developer
      community.
 
 - New MCA parameters:
@@ -240,7 +240,7 @@ Open MPI version 2.1.0
     libfabric progress model to be used for control and data.
 
 - Fix MPI_WTICK regression where the time reported may be inaccurate
-  on systems with processor frequency scalaing enabled.
+  on systems with processor frequency scaling enabled.
 - Fix regression that lowered the memory maximum message bandwidth for
   large messages on some BTL network transports, such as openib, sm,
   and vader.
@@ -305,7 +305,7 @@ Open MPI version 2.1.0
   "test".  Thanks to Kevin Buckley for pointing out the issue.
 - Fix bug when using darrays with lib and extent of darray datatypes.
 - Updates to make Open MPI binary builds more bit-for-bit
-  reproducable.  Thanks to Alastair McKinstry for the suggestion.
+  reproducible.  Thanks to Alastair McKinstry for the suggestion.
 - Fix issues regarding persistent request handling.
 - Ensure that shmemx.h is a standalone OpenSHMEM header file.  Thanks
   to Nick Park (@nspark) for the report.
@@ -527,11 +527,11 @@ Open MPI version 2.0.1
   all transports.
 - Fix shared memory performance when using RDMA-capable networks.
   Thanks to Tetsuya Mishima and Christoph Niethammer for reporting.
-- Fix bandwith performance degredation in the yalla (MXM) PML.  Thanks
+- Fix bandwidth performance degradation in the yalla (MXM) PML.  Thanks
   to Andreas Kempf for reporting the issue.
 - Fix OpenSHMEM crash when running on non-Mellanox MXM-based networks.
   Thanks to Debendra Das for reporting the issue.
-- Fix a crash occuring after repeated calls to MPI_FILE_SET_VIEW with
+- Fix a crash occurring after repeated calls to MPI_FILE_SET_VIEW with
   predefined datatypes.  Thanks to Eric Chamberland and Matthew
   Knepley for reporting and helping chase down this issue.
 - Fix stdin propagation to MPI processes.  Thanks to Jingchao Zhang
@@ -540,7 +540,7 @@ Open MPI version 2.0.1
   internal component to v1.1.5.
 - Fix process startup failures on Intel MIC platforms due to very
   large entries in ``/proc/mounts``.
-- Fix a problem with use of relative path for specifing executables to
+- Fix a problem with use of relative path for specifying executables to
   mpirun / oshrun.  Thanks to David Schneider for reporting.
 - Various improvements when running over portals-based networks.
 - Fix thread-based race conditions with GNI-based networks.
@@ -641,7 +641,7 @@ Open MPI version 2.0.0
    - ompi-release#1081: Support MPI_IN_PLACE in MPI_(I)ALLTOALLW and MPI_(I)EXSCAN
    - ompi-release#1107: Allow future PMIx support for RM spawn limits
    - ompi-release#1108: Fix sparse group process reference counting
-   - ompi-release#1109: If specified to be oversubcribed, disable binding
+   - ompi-release#1109: If specified to be oversubscribed, disable binding
    - ompi-release#1122: Allow NULL arrays for empty datatypes
    - ompi-release#1123: Fix signed vs. unsigned compiler warnings
    - ompi-release#1123: Make max hostname length uniform across code base
@@ -748,7 +748,7 @@ Open MPI version 2.0.0
 - Allow NULL arrays when creating empty MPI datatypes.
 - Replace use of alloca with malloc for certain datatype creation
   functions.  Thanks to Bogdan Sataric for reporting this.
-- Fix use of MPI_LB and MPI_UB in creation of of certain MPI datatypes.
+- Fix use of MPI_LB and MPI_UB in creation of certain MPI datatypes.
   Thanks to Gus Correa for helping to fix this.
 - Implement a workaround for a GNU Libtool problem.  Thanks to Eric
   Schnetter for reporting and fixing.
diff --git a/docs/release-notes/changelog/v3.0.x.rst b/docs/release-notes/changelog/v3.0.x.rst
index 27578071121..f76b4c97b42 100644
--- a/docs/release-notes/changelog/v3.0.x.rst
+++ b/docs/release-notes/changelog/v3.0.x.rst
@@ -63,7 +63,7 @@ Open MPI version 3.0.5
 - Add support for unwinding info to all files that are present in the
   stack starting from ``MPI_Init``, which is helpful with parallel
   debuggers.  Thanks to James Clark for the report and initial fix.
-- Fixed inadvertant use of bitwise operators in the MPI C++ bindings
+- Fixed inadvertent use of bitwise operators in the MPI C++ bindings
   header files.  Thanks to Bert Wesarg for the report and the fix.
 - Added configure option ``--disable-wrappers-runpath`` (alongside the
   already-existing ``--disable-wrappers-rpath`` option) to prevent Open
@@ -79,7 +79,7 @@ Open MPI version 3.0.4
   ``--with-devel-headers``.  Thanks to @g-raffy for reporting the issue.
 - Fix possible floating point rounding and division issues in OMPIO
   which led to crashes and/or data corruption with very large data.
-  Thanks to Axel Huebl and René Widera for identifing the issue,
+  Thanks to Axel Huebl and René Widera for identifying the issue,
   supplying and testing the fix (** also appeared: v3.0.4).
 - Use ``static_cast<>`` in ``mpi.h`` where appropriate.  Thanks to @shadow-fx
   for identifying the issue.
@@ -152,7 +152,7 @@ Open MPI version 3.0.2
   rather than those documented in the MPI standard.
 - Fixed ``MPI_SIZEOF`` in the "mpi" Fortran module for the NAG compiler.
 - Fix RMA function signatures for ``use-mpi-f08`` bindings to have the
-  asynchonous property on all buffers.
+  asynchronous property on all buffers.
 - Fix Fortran ``MPI_COMM_SPAWN_MULTIPLE`` to properly follow the count
   length argument when parsing the array_of_commands variable.
 - Revamp Java detection to properly handle new Java versions which do
@@ -197,9 +197,9 @@ Open MPI version 3.0.1
   propagation tools.  By default it is set to false, except for Cray XC systems.
 - Fix a problem reported on the mailing separately by Kevin McGrattan and Stephen
   Guzik about consistency issues on NFS file systems when using OMPIO. This fix
-  also introduces a new mca parameter ``fs_ufs_lock_algorithm`` which allows to
+  also introduces a new mca parameter ``fs_ufs_lock_algorithm`` which allows users to
   control the locking algorithm used by ompio for read/write operations. By
-  default, ompio does not perfom locking on local UNIX file systems, locks the
+  default, ompio does not perform locking on local UNIX file systems, locks the
   entire file per operation on NFS file systems, and selective byte-range
   locking on other distributed file systems.
 - Add an mca parameter ``pmix_server_usock_connections`` to allow mpirun to
diff --git a/docs/release-notes/changelog/v3.1.x.rst b/docs/release-notes/changelog/v3.1.x.rst
index 68502fce637..6a6e5371b32 100644
--- a/docs/release-notes/changelog/v3.1.x.rst
+++ b/docs/release-notes/changelog/v3.1.x.rst
@@ -78,7 +78,7 @@ Open MPI version 3.1.5
 - Add support for unwinding info to all files that are present in the
   stack starting from MPI_Init, which is helpful with parallel
   debuggers.  Thanks to James Clark for the report and initial fix.
-- Fixed inadvertant use of bitwise operators in the MPI C++ bindings
+- Fixed inadvertent use of bitwise operators in the MPI C++ bindings
   header files.  Thanks to Bert Wesarg for the report and the fix.
 
 
@@ -93,7 +93,7 @@ Open MPI version 3.1.4
   Easterday for the fix.
 - Fix possible floating point rounding and division issues in OMPIO
   which led to crashes and/or data corruption with very large data.
-  Thanks to Axel Huebl and René Widera for identifing the issue,
+  Thanks to Axel Huebl and René Widera for identifying the issue,
   supplying and testing the fix (** also appeared: v3.0.4).
 - Use ``static_cast<>`` in ``mpi.h`` where appropriate.  Thanks to @shadow-fx
   for identifying the issue (** also appeared: v3.0.4).
@@ -193,7 +193,7 @@ Open MPI version 3.1.1
 - Revamp Java detection to properly handle new Java versions which do
   not provide a javah wrapper.
 - Fix RMA function signatures for use-mpi-f08 bindings to have the
-  asynchonous property on all buffers.
+  asynchronous property on all buffers.
 - Improved configure logic for finding the UCX library.
 
 
diff --git a/docs/release-notes/changelog/v4.0.x.rst b/docs/release-notes/changelog/v4.0.x.rst
index 70d452c0619..e7db8a26ac0 100644
--- a/docs/release-notes/changelog/v4.0.x.rst
+++ b/docs/release-notes/changelog/v4.0.x.rst
@@ -153,7 +153,7 @@ Open MPI version 4.0.2
   Thanks to Orivej Desh for reporting and providing a fix.
 - Fix divide by zero segfault in ompio.
   Thanks to @haraldkl for reporting and providing a fix.
-- Fix finalize of flux compnents.
+- Fix finalize of flux components.
   Thanks to Stephen Herbein and Jim Garlick for providing a fix.
 - Fix osc_rdma_acc_single_intrinsic regression.
   Thanks to Joseph Schuchart for reporting and providing a fix.
@@ -231,7 +231,7 @@ Open MPI version 4.0.1
   Thanks to Igor Andriyash and Axel Huebl for reporting.
 - Fix two memory leaks encountered for certain MPI-RMA usage patterns.
   Thanks to Joseph Schuchart for reporting and fixing.
-- Fix a problem with the ORTE ``rmaps_base_oversubscribe`` MCA paramater.
+- Fix a problem with the ORTE ``rmaps_base_oversubscribe`` MCA parameter.
   Thanks to @iassiour for reporting.
 - Fix a problem with UCX PML default error handler for MPI communicators.
   Thanks to Marcin Krotkiewski for reporting.
@@ -277,7 +277,7 @@ Open MPI version 4.0.0
 - Fix problems with use of newer map-by mpirun options.  Thanks to
   Tony Reina for reporting.
 - Fix rank-by algorithms to properly rank by object and span
-- Allow for running as root of two environment variables are set.
+- Allow for running as root if two environment variables are set.
   Requested by Axel Huebl.
 - Fix a problem with building the Java bindings when using Java 10.
   Thanks to Bryce Glover for reporting.
diff --git a/docs/release-notes/changelog/v4.1.x.rst b/docs/release-notes/changelog/v4.1.x.rst
index f5540505189..f8d35dd0bee 100644
--- a/docs/release-notes/changelog/v4.1.x.rst
+++ b/docs/release-notes/changelog/v4.1.x.rst
@@ -31,7 +31,7 @@ Open MPI version 4.1.6
 - Fix minor issues and add some minor performance optimizations with
   OFI support.
 - Support the ``striping_factor`` and ``striping_unit`` MPI_Info names
-  recomended by the MPI standard for parallel IO.
+  recommended by the MPI standard for parallel IO.
 - Fixed some minor issues with UCX support.
 - Minor optimization for 0-byte MPI_Alltoallw (i.e., make it a no-op).
 
@@ -119,7 +119,7 @@ Open MPI version 4.1.3
   based on float precision.
 - Fix compile failure for ``--enable-heterogeneous``.  Also updated
   the README to clarify that ``--enable-heterogeneous`` is functional,
-  but still not recomended for most environments.
+  but still not recommended for most environments.
 - Minor fixes to OMPIO, including:
 
   - Fixing the open behavior of shared memory shared file pointers.
@@ -154,7 +154,7 @@ Open MPI version 4.1.2
 - Correctly process 0 slots with the ``mpirun --host`` option.
 - Ensure to unlink and rebind socket when the Open MPI session
   directory already exists.
-- Fix a segv in ``mpirun --disable-dissable-map``.
+- Fix a segv in ``mpirun --disable-display-map``.
 - Fix a potential hang in the memory hook handling.
 - Slight performance improvement in ``MPI_WAITALL`` when running in
   ``MPI_THREAD_MULTIPLE``.
diff --git a/docs/release-notes/changelog/v6.0.x.rst b/docs/release-notes/changelog/v6.0.x.rst
index 6b3038ee6bc..b797608ea56 100644
--- a/docs/release-notes/changelog/v6.0.x.rst
+++ b/docs/release-notes/changelog/v6.0.x.rst
@@ -29,6 +29,14 @@ Open MPI version v6.0.0
   delivered through the Open MPI internal "OMPIO" implementation
   (which has been the default for quite a while, anyway).
 
+- Removed the Java MPI bindings and the ``--enable-mpi-java``
+  configure option.  These bindings were experimental, were never part
+  of the MPI standard, and are no longer supported.
+
+- Improved OMPIO ``MPI_File_get_info()`` reporting so it returns
+  supported file hints that OMPIO is actually using, including
+  component-owned hints for selected OMPIO subcomponents.
+
 - Added support for MPI-4.1 functions to access and update ``MPI_Status``
   fields.
 
@@ -68,3 +76,8 @@ Open MPI version v6.0.0
 
   - Extended the ``accelerator`` collective component to support
     more collective operations on device buffers.
+
+- ``MPI_T_category_get_events`` and ``MPI_T_category_get_num_events``
+  now validate their ``cat_index`` argument and return
+  ``MPI_T_ERR_INVALID_INDEX`` for an out-of-range index, consistent
+  with the other ``MPI_T_category_get_*`` query functions.
diff --git a/docs/release-notes/changelog/v6.1.x.rst b/docs/release-notes/changelog/v6.1.x.rst
new file mode 100644
index 00000000000..d53681a89f5
--- /dev/null
+++ b/docs/release-notes/changelog/v6.1.x.rst
@@ -0,0 +1,24 @@
+Open MPI v6.1.x series
+======================
+
+This file contains all the NEWS updates for the Open MPI v6.1.x
+series, in reverse chronological order.
+
+Open MPI version v6.1.0
+--------------------------
+:Date: ...fill me in...
+
+- Renamed the ``--enable-weak-symbols`` configure option to
+  ``--enable-weak-aliases``, which more accurately reflects the linker
+  feature (weak symbol *aliases*) that Open MPI actually tests for and
+  uses.  ``--enable-weak-symbols`` is retained as a deprecated synonym.
+
+- The documentation now publishes machine-readable, LLM-friendly
+  artifacts for the public MPI APIs alongside the human-facing HTML and
+  man pages: a JSONL API catalog, aggregate and per-interface Markdown
+  corpora, per-symbol Markdown pages, curated examples, an interface
+  guide, an ``ompi_info`` runtime-introspection guide (how to query an
+  installed Open MPI for its version, configuration, components, and
+  run-time MCA parameters), and a manifest, all indexed from
+  ``llms.txt``. See the "LLM-friendly documentation artifacts" page in
+  the developer documentation.
diff --git a/docs/release-notes/networks.rst b/docs/release-notes/networks.rst
index 400bf21f9cd..cf5f42c4665 100644
--- a/docs/release-notes/networks.rst
+++ b/docs/release-notes/networks.rst
@@ -23,8 +23,7 @@ There are multiple MPI network models available in this release:
   utilizing MTL ("Matching Transport Layer") plugins:
 
   * OpenFabrics Interfaces ("libfabric" tag matching)
-  * Intel Omni-Path PSM2 (version 11.2.173 or later)
-  * Intel True Scale PSM (QLogic InfiniPath)
+  * Cornelis Networks Omni-Path PSM2 (version 11.2.173 or later)
   * Portals 4
 
 * ``ucx`` uses the `Unified Communication X (UCX) communication
@@ -60,7 +59,7 @@ run-time:
 
 .. code-block:: sh
 
-   shell$ mpirun --mca pml ob1 --mca btl [comma-delimted-BTLs] ...
+   shell$ mpirun --mca pml ob1 --mca btl [comma-delimited-BTLs] ...
    # or
    shell$ mpirun --mca pml cm --mca mtl [MTL] ...
    # or
diff --git a/docs/release-notes/platform.rst b/docs/release-notes/platform.rst
index ec6ead13598..f67d3cc3f9c 100644
--- a/docs/release-notes/platform.rst
+++ b/docs/release-notes/platform.rst
@@ -3,53 +3,133 @@
 Platform Notes
 ==============
 
-.. error:: **TODO We should have a canonical list of:**
-
-   *  *required* 3rd-party package versions supported (PRRTE, hwloc,
-      libevent)
-   * back-end run-time systems supported (behind PRRTE)
-   * OS's and compilers supported
-   * network interconnects supported.
-
 Open MPI uses both `OpenPMIx <https://openpmix.github.io/>`_ and
-`PRRTE <https://github.com/openpmix/prrte>`_ for its run-time system support,
-and therefore supports whatever run-time systems they support.
+`PRRTE <https://github.com/openpmix/prrte>`_ for its run-time system
+support, and therefore supports whatever run-time systems they support.
 
 .. note:: See the :ref:`PMIx and PRRTE section
           <label-running-role-of-pmix-and-prte>` of the Open MPI
           documentation for more details about those projects and
           their relationship to Open MPI.
 
-Each version of Open MPI supports a specific set of versions of
-OpenPMIx and PRRTE.  Those versions therefore determine which run-time systems
-that a release of Open MPI supports.
+Required support libraries
+--------------------------
+
+Open MPI |ompi_ver| depends on the following support libraries.  Each
+may be supplied by a system installation (if it is recent enough) or
+used from the copy embedded in the Open MPI distribution:
+
+* `OpenPMIx <https://openpmix.github.io/>`_: version
+  |pmix_min_version| or later when building without PRRTE (when
+  building with PRRTE, PRRTE's own OpenPMIx minimum applies).  Open
+  MPI |ompi_ver| embeds OpenPMIx |pmix_embedded_version|.
+* `PRRTE <https://github.com/openpmix/prrte>`_: version
+  |prte_min_version| or later.  Open MPI |ompi_ver| embeds PRRTE
+  |prte_embedded_version|.  PRRTE is what provides ``mpirun``; it is
+  not needed if MPI jobs are always launched directly by a
+  PMIx-enabled resource manager.
+* `hwloc <https://www.open-mpi.org/projects/hwloc/>`_: version
+  |hwloc_min_version| or later, and older than v3.0.0 (Open MPI does
+  not yet support the hwloc v3.x series).  Open MPI |ompi_ver| embeds
+  hwloc |hwloc_embedded_version|.
+* `Libevent <https://libevent.org/>`_: version |event_min_version| or
+  later.  Open MPI |ompi_ver| embeds Libevent
+  |event_embedded_version|.
+
+See the :ref:`Required support libraries section
+<label-install-required-support-libraries>` for the full details,
+including how ``configure`` chooses between an embedded and an
+external copy of each library.
+
+The versions of OpenPMIx and PRRTE that a given Open MPI release
+supports determine which back-end run-time systems that release
+supports.
+
+Building Open MPI additionally requires Perl 5 and Python
+|python_min_version| or later.  These are needed only to *build* Open
+MPI itself |mdash| not to build or run MPI applications.
+
+Operating systems and compilers
+-------------------------------
+
+Open MPI |ompi_ver| requires a C11 (or newer) C compiler.
 
 * Systems that have been tested are:
 
-  * Linux (various flavors/distros), 64 bit (x86, ppc, aarch64),
-    with gcc/gfortran (>=7.x+), clang (>=10.x), Intel,
-    and Portland (be sure to also see :ref:`the Compiler Notes
-    section <compiler-notes-section-label>`)
-  * macOS (14.x, 15.x), 64 bit (x86_64) with XCode compilers
+  * Linux (various flavors/distros), 64 bit (x86, ppc, aarch64), with
+    gcc/gfortran (>= 7.x), clang (>= 10.x), Intel, and NVIDIA (be sure
+    to also see :ref:`the Compiler Notes section
+    <compiler-notes-section-label>`)
+  * macOS (26.x), 64 bit (arm64/Apple silicon), with Xcode compilers.
+    This is the macOS platform exercised by Open MPI's GitHub Actions
+    CI, which builds, runs ``make check``, and runs the example
+    programs on the ``macos-latest`` runner image.
 
 * Other systems have been lightly (but not fully) tested:
 
+  * macOS on 64 bit x86_64 (Intel) hardware with Xcode compilers.
+    Open MPI is expected to work here, but it is not covered by CI.
   * Cygwin 64 bit with gcc
   * ARMv6, ARMv7, ARMv9
   * Other 64 bit platforms.
-  * OpenBSD.  Requires configure options ``--enable-mca-no-build=patcher``
-    and ``--disable-dlopen`` with this release.
+  * OpenBSD.  Requires configure options
+    ``--enable-mca-no-build=patcher`` and ``--disable-dlopen`` with
+    this release.
   * Problems have been reported when building Open MPI on FreeBSD 11.1
-    using the clang-4.0 system compiler. A workaround is to build
+    using the clang-4.0 system compiler.  A workaround is to build
     Open MPI using the GNU compiler.
 
 .. note:: 32-bit environments are no longer supported.
 
-* The run-time systems that are currently supported are:
+Run-time systems
+----------------
+
+Because Open MPI delegates launch to PRRTE, the supported back-end
+run-time systems are those that PRRTE supports.  The currently
+supported run-time systems are:
+
+* **ssh / rsh:** used in non-scheduled environments, and also to launch
+  within an allocation from a resource manager that does not provide
+  its own launch mechanism.  See :doc:`Launching with SSH
+  </launching-apps/ssh>`.
+* **Slurm:** Open MPI obtains the node list and slot counts from
+  Slurm, and uses Slurm's native mechanisms to start processes.
+  Slurm's ``srun`` "direct launch" mode is also supported.  See
+  :doc:`Launching with Slurm </launching-apps/slurm>`.
+* **PBS Pro / Torque / OpenPBS:** the allocation is obtained from the
+  resource manager, and processes are started via the TM interface.
+  See :doc:`Launching with PBS / Torque </launching-apps/tm>`.
+* **Platform LSF** (tested with v9.1.1 and later): the allocation is
+  obtained from LSF, and processes are started via LSF's native
+  mechanisms.  Problems have been reported with the most recent LSF
+  releases; see :doc:`Launching with LSF </launching-apps/lsf>` for
+  the details and a workaround.
+* **HPE PALS:** processes are started via the Parallel Application
+  Launch Service on HPE systems; PALS' ``aprun`` "direct launch" mode
+  is also supported.  See :doc:`Launching with HPE PALS
+  </launching-apps/pals>`.
+* **Grid Engine:** the allocation is obtained from Grid Engine, and
+  processes are started via ``qrsh`` so that Grid Engine can monitor
+  and control them.  This covers the whole Grid Engine family (Oracle
+  Grid Engine, Son of Grid Engine, Altair/Univa Grid Engine, Open
+  Cluster Scheduler, and friends); it must be explicitly enabled with
+  ``configure --with-sge``.  See :doc:`Launching with Grid Engine
+  </launching-apps/gridengine>`.
+* **Flux:** the allocation is obtained from Flux, but Flux provides no
+  native launch mechanism to PRRTE; processes within the allocation
+  are started via ``ssh``.
+
+Network interconnects
+---------------------
+
+The primary network transports that Open MPI supports are:
+
+* Shared memory, for on-node communication
+* TCP / IP
+* InfiniBand and RoCE, via `UCX <https://openucx.org/>`_
+* Networks supported by `Libfabric (OFI) <https://libfabric.org/>`_,
+  including AWS EFA, Cornelis Networks Omni-Path, and HPE Slingshot
+* Cisco usNIC
 
-  * ssh / rsh
-  * PBS Pro, Torque
-  * Platform LSF (tested with v9.1.1 and later)
-  * Slurm
-  * HPE/Cray PALS
-  * Oracle Grid Engine (OGE) 6.1, 6.2 and open source Grid Engine
+See the networking pages under :doc:`/tuning-apps/index` for
+configuration and tuning details.
diff --git a/docs/requirements.txt b/docs/requirements.txt
index 9fda5a43a4d..be4538dd67b 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -4,6 +4,10 @@ docutils
 sphinx-rtd-theme
 sphobjinv
 
+# Used by validate-llm-docs.py to validate the generated LLM-friendly
+# artifacts against the published JSON Schemas (see "make check").
+jsonschema
+
 # These modules are needed for the pympistandard module when you are
 # running Python 3.6 (they became part of core Python in 3.7).  We
 # specifically use "==" (vs. "<=") because the top-level Open MPI
diff --git a/docs/tuning-apps/_include/ompio-mpi-info-hints.rst b/docs/tuning-apps/_include/ompio-mpi-info-hints.rst
new file mode 100644
index 00000000000..a0162695e35
--- /dev/null
+++ b/docs/tuning-apps/_include/ompio-mpi-info-hints.rst
@@ -0,0 +1,152 @@
+MPI allows applications to pass ``MPI_Info`` hints to
+:ref:`MPI_File_open`, :ref:`MPI_File_set_view`, and
+:ref:`MPI_File_set_info`.  Hints are advisory: OMPIO may ignore hints
+that are not supported in the selected component stack.  The
+:ref:`MPI_File_get_info` routine returns a new ``MPI_Info`` object
+containing the public hints that OMPIO currently associates with the
+file.  The caller is responsible for freeing that returned object with
+:ref:`MPI_Info_free`.
+
+OMPIO preserves the spelling of a supported hint that was accepted
+from the user's ``MPI_Info`` object.  When OMPIO reports an internal
+default that did not come from a user-supplied hint, it uses the
+canonical public spelling shown below.
+
+OMPIO common hints
+^^^^^^^^^^^^^^^^^^
+
+.. list-table::
+   :header-rows: 1
+
+   * - Hint
+     - Accepted by
+     - Default / MCA parameter
+     - Notes
+   * - ``cb_buffer_size``
+     - ``MPI_File_open``, ``MPI_File_set_info``,
+       ``MPI_File_set_view``
+     - ``io_ompio_bytes_per_agg``
+     - Size, in bytes, of the temporary collective I/O buffer on each
+       aggregator.
+   * - ``cb_nodes``
+     - ``MPI_File_open``, ``MPI_File_set_info``,
+       ``MPI_File_set_view``
+     - ``io_ompio_num_aggregators`` when that MCA parameter is set to
+       a non-negative value.
+     - Number of collective I/O aggregators.  When OMPIO is using its
+       automatic aggregator selection, this hint is not returned as
+       ``-1``.
+   * - ``collective_buffering``
+     - ``MPI_File_open``, ``MPI_File_set_info``,
+       ``MPI_File_set_view``
+     - ``true``
+     - Controls whether collective buffering is enabled for collective
+       I/O decisions.
+
+``sharedfp`` component hints
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. list-table::
+   :header-rows: 1
+
+   * - Component
+     - Hint
+     - Accepted by
+     - Default / MCA parameter
+     - Notes
+   * - ``sharedfp/individual``
+     - ``OMPIO_SHAREDFP_RELAXED_ORDERING``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - If present on a write-capable file open, this hint raises the
+       priority of the ``individual`` shared file pointer component.
+       OMPIO reports it only when that component is selected for the
+       file.
+
+Lustre ``fs`` component hints
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The Lustre layout hints affect file layout creation.  Lustre applies
+these settings only when a file is created in a mode where layout can
+be set safely; changing them after a file has been opened does not
+change the already-created file layout.
+
+.. list-table::
+   :header-rows: 1
+
+   * - Canonical hint
+     - Accepted alias
+     - Accepted by
+     - Default / MCA parameter
+     - Notes
+   * - ``striping_unit``
+     - ``stripe_size``
+     - ``MPI_File_open``
+     - ``fs_lustre_stripe_size`` when greater than zero.
+     - Stripe size in bytes.
+   * - ``striping_factor``
+     - ``stripe_width``
+     - ``MPI_File_open``
+     - ``fs_lustre_stripe_width`` when greater than zero.
+     - Number of Lustre object storage targets to stripe across.
+
+If an application supplies an alias, :ref:`MPI_File_get_info` returns
+the alias spelling.  If both a canonical hint and its alias are
+supplied, OMPIO prefers the canonical spelling.  If only an MCA
+parameter supplies the value, OMPIO reports the canonical spelling.
+
+GPFS ``fs`` component hints
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The GPFS component accepts the hints listed below when the GPFS
+component is built and selected.  These hints are consumed when the
+file is opened.  Later ``MPI_File_set_info`` or ``MPI_File_set_view``
+calls do not reapply them to GPFS, and :ref:`MPI_File_get_info`
+continues to report the open-time accepted values.
+
+.. list-table::
+   :header-rows: 1
+
+   * - Hint
+     - Accepted by
+     - Default / MCA parameter
+     - Notes
+   * - ``useSIOXLib``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Enables optional SIOX-assisted GPFS I/O selection when SIOX
+       support is compiled in.
+   * - ``gpfsAccessRange``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Passed to GPFS as an access range hint.
+   * - ``gpfsFreeRange``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Passed to GPFS as a free range hint.
+   * - ``gpfsClearFileCache``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Requests GPFS file-cache clearing.
+   * - ``gpfsCancelHints``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Requests cancellation of GPFS hints.
+   * - ``gpfsSetReplication``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Passed to GPFS as a replication hint.
+   * - ``gpfsByteRange``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Passed to GPFS as a byte range hint.
+   * - ``gpfsRestripeData``
+     - ``MPI_File_open``
+     - No default; no corresponding MCA parameter.
+     - Requests GPFS data restriping.
+
+When SIOX support is compiled in, the GPFS component also accepts:
+``sioxAccessRange``, ``sioxFreeRange``, ``sioxClearFileCache``,
+``sioxCancelHints``, ``sioxDataShipStart``, ``sioxDataShipStop``,
+``sioxSetReplication``, ``sioxByteRange``, and
+``sioxRestripeData``.
diff --git a/docs/tuning-apps/accelerators/cuda.rst b/docs/tuning-apps/accelerators/cuda.rst
index 8a393b3f32f..b3025cfc35c 100644
--- a/docs/tuning-apps/accelerators/cuda.rst
+++ b/docs/tuning-apps/accelerators/cuda.rst
@@ -1,265 +1,353 @@
 CUDA
 ====
 
-.. error:: TODO This section needs to be converted from FAQ Q&A style
-           to regular documentation style.
-
-How do I build Open MPI with CUDA-aware support?
-------------------------------------------------
-
 CUDA-aware support means that the MPI library can send and receive GPU
-buffers directly.  CUDA support is being continuously updated so
-different levels of support exist in different versions.  We recommend
-you use the latest version of Open MPI for best support.
+buffers directly, without the application first staging them into host
+memory.  Open MPI automatically detects that a buffer passed to an MPI
+routine is a CUDA device pointer and handles it appropriately; this
+detection relies on CUDA's Unified Virtual Addressing (UVA), which lets
+the library determine whether a given pointer refers to device or host
+memory.
+
+CUDA support is updated continuously, and different levels of support
+exist in different versions, so we recommend using the latest release
+of Open MPI for the best support.  Open MPI offers two flavors of CUDA
+support, described below; you may build with either or both.
+
+Building Open MPI with CUDA-aware support
+-----------------------------------------
 
-Open MPI offers two flavors of CUDA support:
+Regardless of which flavor of CUDA support you plan to use, configure
+Open MPI with the ``--with-cuda=<path-to-cuda>`` option to build in
+CUDA support.  The configure script searches the given path for
+``libcuda.so``; if it cannot be found, also pass
+``--with-cuda-libdir``, for example:
+
+.. code-block:: sh
 
-#. Via `UCX <https://openucx.org/>`_.
+   shell$ ./configure --with-cuda=/usr/local/cuda \
+          --with-cuda-libdir=/usr/local/cuda/lib64/stubs <other configure params>
 
-   This is the preferred mechanism.  Since UCX will be providing the
-   CUDA support, it is important to ensure that UCX itself is built
-   with CUDA support.
+Support via UCX
+^^^^^^^^^^^^^^^
 
-   To see if your ucx was built with CUDA support run the following
-   command:
+Using `UCX <https://openucx.org/>`_ is the preferred mechanism.  Since
+UCX provides the CUDA support in this configuration, it is important
+that UCX itself is built with CUDA support.  To check whether your UCX
+was built with CUDA support, run:
 
-   .. code-block:: sh
+.. code-block:: sh
 
-      # Check if ucx was built with CUDA support
-      shell$ ucx_info -v
+   shell$ ucx_info -v
 
-      # configured with: --build=powerpc64le-redhat-linux-gnu --host=powerpc64le-redhat-linux-gnu --program-prefix= --disable-dependency-tracking --prefix=/usr --exec-prefix=/usr --bindir=/usr/bin --sbindir=/usr/sbin --sysconfdir=/etc --datadir=/usr/share --includedir=/usr/include --libdir=/usr/lib64 --libexecdir=/usr/libexec --localstatedir=/var --sharedstatedir=/var/lib --mandir=/usr/share/man --infodir=/usr/share/info --disable-optimizations --disable-logging --disable-debug --disable-assertions --enable-mt --disable-params-check --enable-cma --without-cuda --without-gdrcopy --with-verbs --with-cm --with-knem --with-rdmacm --without-rocm --without-xpmem --without-java
+and look for ``--with-cuda`` in the reported configure line.  If you
+need to build UCX yourself to include CUDA support, see the UCX
+documentation for `building UCX with Open MPI
+<https://openucx.readthedocs.io/en/master/running.html#openmpi-with-ucx>`_.
+A typical build looks like:
 
-   If you need to build ucx yourself to include CUDA support, please
-   see the UCX documentation for `building ucx with Open MPI: <https://openucx.readthedocs.io/en/master/running.html#openmpi-with-ucx>`_
+.. code-block:: sh
 
-   It should look something like:
+   # Configure UCX with CUDA support
+   shell$ ./configure --prefix=/path/to/ucx-cuda-install \
+          --with-cuda=/usr/local/cuda --with-gdrcopy=/usr
 
-   .. code-block:: sh
+   # Configure Open MPI to use that UCX
+   shell$ ./configure --with-cuda=/usr/local/cuda \
+          --with-ucx=/path/to/ucx-cuda-install <other configure params>
 
-      # Configure UCX this way
-      shell$ ./configure --prefix=/path/to/ucx-cuda-install --with-cuda=/usr/local/cuda --with-gdrcopy=/usr
+Internal Open MPI CUDA support
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-      # Configure Open MPI this way
-      shell$ ./configure --with-cuda=/usr/local/cuda --with-ucx=/path/to/ucx-cuda-install <other configure params>
+Open MPI also provides its own internal CUDA support, used by the
+CUDA-ized components such as the ``smcuda`` shared-memory BTL.  This is
+enabled by the same ``--with-cuda`` option.
 
-#. Via internal Open MPI CUDA support
+Running on hosts without CUDA
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Regardless of which flavor of CUDA support (or both) you plan to use,
-Open MPI should be configured using the ``--with-cuda=<path-to-cuda>``
-configure option to build CUDA support into Open MPI. The configure
-script will automatically search the path given for ``libcuda.so``. If it cannot
-be found, please also pass ``--with-cuda-libdir``. For example:
-``--with-cuda=<path-to-cuda> --with-cuda-libdir=/usr/local/cuda/lib64/stubs``.
+Open MPI supports building with CUDA libraries and then running on
+systems that have neither CUDA libraries nor CUDA hardware.  For
+releases v5.0.2 and newer, no special steps are required.
 
-Open MPI supports building with CUDA libraries and running on systems
-without CUDA libraries or hardware.
+For the v5.0.0 and v5.0.1 releases only, you must build the
+CUDA-dependent components as DSOs to get this behavior, using the
+``--enable-mca-dso`` option.  This affects the ``smcuda`` shared-memory
+and ``uct`` BTLs, as well as the ``rgpusm`` and ``gpusm`` rcache
+components:
 
-For releases v5.0.2 and newer no special steps are required to get this behavior.
+.. code-block:: sh
 
-In order to realize this behavior for the v5.0.0 and v5.0.1 releases,
-when configuring Open MPI, you have to specify the CUDA dependent components to be built as DSOs using the
-``--enable-mca-dso=<comma-delimited-list-of-cuda-components.``
-configure option.
+   shell$ ./configure --with-cuda=/usr/local/cuda \
+          --enable-mca-dso=btl-smcuda,rcache-rgpusm,rcache-gpusm,accelerator-cuda \
+          <other configure params>
 
-This affects the ``smcuda`` shared memory and ``uct`` BTLs, as well
-as the ``rgpusm`` and ``gpusm`` rcache components.
+Building with the NVIDIA compilers
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-An example configure command would look like the following:
+With CUDA 6.5 and later, CUDA-aware Open MPI builds with the NVIDIA
+compilers without anything special.  With CUDA 7.0 and 7.5, some
+additional compiler flags are required:
 
-   .. code-block:: sh
+.. code-block:: sh
 
-      # Configure Open MPI this way
-      shell$ ./configure --with-cuda=/usr/local/cuda \
-             --enable-mca-dso=btl-smcuda,rcache-rgpusm,rcache-gpusm,accelerator-cuda <other configure params>
+   # For NVIDIA compilers version 15.9 and later
+   shell$ ./configure --with-wrapper-cflags=-ta:tesla
 
-/////////////////////////////////////////////////////////////////////////
+   # For earlier NVIDIA compiler versions
+   shell$ ./configure CFLAGS=-D__LP64__ \
+          --with-wrapper-cflags="-D__LP64__ -ta:tesla"
 
-How do I verify that Open MPI has been built with CUDA support?
----------------------------------------------------------------
+Verifying that CUDA support was built
+-------------------------------------
 
-Verify that Open MPI has been built with cuda using ``ompi_info``
-with one of the following commands.
+Use :ref:`ompi_info(1) <man1-ompi_info>` to confirm that a given Open
+MPI installation was built with CUDA support:
 
 .. code-block:: sh
 
-   # Use ompi_info to verify cuda support in Open MPI
+   # List the MPI extensions that were built
    shell$ ompi_info | grep "MPI extensions"
-          MPI extensions: affinity, cuda, pcollreq
+          MPI extensions: affinity, cuda, ftmpi, rocm
+
+   # Query the CUDA support MCA parameter directly
    shell$ ompi_info --parsable --all | grep mpi_built_with_cuda_support:value
           mca:mpi:base:param:mpi_built_with_cuda_support:value:true
 
-/////////////////////////////////////////////////////////////////////////
-
-How do I run Open MPI with applications that pass CUDA buffers to MPI?
-----------------------------------------------------------------------
-
-Open MPI will detect and enable CUDA enabled components at runtime with
-no additional mpirun parameters.
-
-/////////////////////////////////////////////////////////////////////////
-
-How do I build Open MPI with CUDA-aware support using PGI?
-----------------------------------------------------------
+Detecting CUDA-aware support at compile and run time
+----------------------------------------------------
 
-With CUDA 6.5, you can build all versions of CUDA-aware Open MPI
-without doing anything special.  However, with CUDA 7.0 and CUDA 7.5,
-you need to pass in some specific compiler flags for things to work
-correctly.  Add the following to your configure line.
+The ``cuda`` MPI extension provides both a compile-time and a run-time
+check, and you can use whichever is more convenient.  Both require
+including the Open MPI-specific header ``<mpi-ext.h>``:
 
-.. code-block:: sh
+* The compile-time check is the ``MPIX_CUDA_AWARE_SUPPORT`` macro.
+* The run-time check is the :ref:`MPIX_Query_cuda_support(3)
+  <mpix_query_cuda_support>` function.
 
-   # For PGI 15.9 and later (Also called NVCC):
-   shell$ ./configure --with-wrapper-cflags=-ta:tesla
+The extension is built by default, whether or not Open MPI itself was
+built with CUDA-aware support; when support is absent, the run-time
+check simply returns ``0``.  The following program illustrates both
+checks:
 
-   # For earlier versions of PGI:
-   shell$ ./configure CFLAGS=-D__LP64__ --with-wrapper-cflags="-D__LP64__ -ta:tesla"
+.. code-block:: c
 
-/////////////////////////////////////////////////////////////////////////
+   /*
+    * Program that shows the use of the CUDA-aware macro and run-time check.
+    */
+   #include <stdio.h>
+   #include "mpi.h"
 
-What kind of CUDA support exists in Open MPI?
----------------------------------------------
+   #if !defined(OPEN_MPI) || !OPEN_MPI
+   #error This source code uses an Open MPI-specific extension
+   #endif
 
-CUDA-aware support is defined as Open MPI automatically detecting that
-the argument pointer being passed to an MPI routine is a CUDA device
-memory pointer.
+   /* Needed for MPIX_Query_cuda_support(), below */
+   #include "mpi-ext.h"
 
-See :ref:`this FAQ entry <faq-cuda-mpi-apis-cuda-label>`
-for more details on which APIs are CUDA-aware.
+   int main(int argc, char *argv[])
+   {
+       MPI_Init(&argc, &argv);
 
+       printf("Compile time check:\n");
+   #if defined(MPIX_CUDA_AWARE_SUPPORT) && MPIX_CUDA_AWARE_SUPPORT
+       printf("This MPI library has CUDA-aware support.\n");
+   #elif defined(MPIX_CUDA_AWARE_SUPPORT) && !MPIX_CUDA_AWARE_SUPPORT
+       printf("This MPI library does not have CUDA-aware support.\n");
+   #else
+       printf("This MPI library cannot determine if there is CUDA-aware support.\n");
+   #endif /* MPIX_CUDA_AWARE_SUPPORT */
 
-.. error:: CUDA 4.0 is SUPER OLD!  End users dont care about the
-   differences between cuda-aware, cuda-ipc, gpu-direct, and gpu-direct-rdma
+       printf("Run time check:\n");
+   #if defined(MPIX_CUDA_AWARE_SUPPORT)
+       if (1 == MPIX_Query_cuda_support()) {
+           printf("This MPI library has CUDA-aware support.\n");
+       } else {
+           printf("This MPI library does not have CUDA-aware support.\n");
+       }
+   #else /* !defined(MPIX_CUDA_AWARE_SUPPORT) */
+       printf("This MPI library cannot determine if there is CUDA-aware support.\n");
+   #endif /* MPIX_CUDA_AWARE_SUPPORT */
 
-Open MPI depends on various features of CUDA 4.0, so one needs to have
-at least the CUDA 4.0 driver and toolkit.  The new features of
-interest are the Unified Virtual Addressing (UVA) so that all pointers
-within a program have unique addresses.  In addition, there is a new
-API that allows one to determine if a pointer is a CUDA device pointer
-or host memory pointer.  This API is used by the library to decide
-what needs to be done with each buffer.  In addition, CUDA 4.1 also
-provides the ability to register host memory with the CUDA driver,
-which can improve performance.  CUDA 4.1 also added CUDA IPC support
-for fast communication between GPUs on the same node.
+       MPI_Finalize();
+       return 0;
+   }
 
-Note that derived datatypes |mdash| both contiguous and non-contiguous
-|mdash| are supported.  However, the non-contiguous datatypes
-currently have high overhead because of the many calls to the CUDA
-function ``cuMemcpy()`` to copy all the pieces of the buffer into the
-intermediate buffer.
+Running applications that pass CUDA buffers
+-------------------------------------------
 
-CUDA-aware support is available in:
+Open MPI detects and enables its CUDA-capable components at run time
+with no additional ``mpirun`` parameters; an application may simply pass
+CUDA device buffers to MPI routines.  CUDA-aware support is available
+in the following transports:
 
-* The UCX (``ucx``) PML
+* The UCX (``ucx``) PML.
 * The PSM2 (``psm2``) MTL with the CM (``cm``) PML.
 * The OFI (``ofi``) MTL with the CM (``cm``) PML.
-* Both CUDA-ized shared memory (``smcuda``) and TCP (``tcp``) BTLs
-  with the OB1 (``ob1``) PML.
-
-/////////////////////////////////////////////////////////////////////////
-
-PSM2 support for CUDA
----------------------
-
-CUDA-aware support is present in PSM2 MTL.  When running CUDA-aware
-Open MPI on Cornelis Networks Omni-Path, the PSM2 MTL will automatically set
-``PSM2_CUDA`` environment variable which enables PSM2 to handle GPU
-buffers.  If the user wants to use host buffers with a CUDA-aware Open
-MPI, it is recommended to set ``PSM2_CUDA`` to ``0`` in the execution
-environment. PSM2 also has support for the NVIDIA GPUDirect support
-feature. To enable this, users will need to set ``PSM2_GPUDIRECT``
-to ``1`` in the execution environment.
-
-Note: The PSM2 library and ``hfi1`` driver with CUDA support are requirements
-to use GPUDirect support on Cornelis Networks Omni-Path. The minimum
-PSM2 build version required is `PSM2 10.2.175
-<https://github.com/01org/opa-psm2/releases/tag/PSM2_10.2-175>`_.
-
-For more information refer to the `Cornelis Networks Customer Center
-<https://customercenter.cornelisnetworks.com/>`_.
-
-/////////////////////////////////////////////////////////////////////////
-
-OFI support for CUDA
----------------------
+* The CUDA-ized shared-memory (``smcuda``) and TCP (``tcp``) BTLs with
+  the OB1 (``ob1``) PML.
 
-CUDA-aware support is present in OFI MTL.  When running CUDA-aware
-Open MPI over Libfabric, the OFI MTL will check if there are any
-providers capable of handling GPU (or other accelerator) memory
-through the ``hmem``-related flags. If a CUDA-capable provider is
-available, the OFI MTL will directly send GPU buffers through
-Libfabric's API after registering the memory. If there are no
-CUDA-capable providers available, the buffers will automatically
-be copied to host buffers before being transferred through
-Libfabric's API.
+Both contiguous and non-contiguous derived datatypes are supported.
+Non-contiguous datatypes currently carry high overhead, however,
+because copying the pieces of the buffer into an intermediate buffer
+requires many separate device-to-device copies.
 
-/////////////////////////////////////////////////////////////////////////
-
-Can I get additional CUDA debug-level information at run-time?
---------------------------------------------------------------
-
-Yes, by enabling some vebosity flags.
-
-* The ``opal_cuda_verbose`` parameter has only one level of verbosity:
-
-  .. code-block::
-
-     shell$ mpirun --mca opal_cuda_verbose 10 ...
-
-
-* The ``mpi_common_cuda_verbose`` parameter provides additional
-  information about CUDA-aware related activities.  This can be set to
-  a variety of different values.  There is really no need to use these
-  unless you have strange problems:
-
-  .. code-block:: sh
-
-     # A bunch of CUDA debug information
-     shell$ mpirun --mca mpi_common_cuda_verbose 10 ...
-     # Even more CUDA debug information
-     shell$ mpirun --mca mpi_common_cuda_verbose 20 ...
-     # Yet more CUDA debug information
-     shell$ mpirun --mca mpi_common_cuda_verbose 100 ...
+.. _faq-cuda-mpi-apis-cuda-label:
 
-* The ``smcuda`` BTL has three MCA parameters related to the use of
-  CUDA IPC.  By default, CUDA IPC is used where possible.  But the
-  user can now turn it off if they prefer.
+CUDA-aware MPI APIs
+-------------------
+
+The following MPI operations accept CUDA device buffers:
+
+* ``MPI_Allgather``, ``MPI_Allgatherv``
+* ``MPI_Allreduce``
+* ``MPI_Alltoall``, ``MPI_Alltoallv``, ``MPI_Alltoallw``
+* ``MPI_Bcast``
+* ``MPI_Bsend``, ``MPI_Bsend_init``
+* ``MPI_Exscan``
+* ``MPI_Gather``, ``MPI_Gatherv``
+* ``MPI_Get``, ``MPI_Put``
+* ``MPI_Ibsend``
+* ``MPI_Irecv``, ``MPI_Isend``, ``MPI_Irsend``, ``MPI_Issend``
+* ``MPI_Recv``, ``MPI_Recv_init``
+* ``MPI_Reduce``, ``MPI_Reduce_scatter``, ``MPI_Reduce_scatter_block``
+* ``MPI_Rsend``, ``MPI_Rsend_init``
+* ``MPI_Scan``
+* ``MPI_Scatter``, ``MPI_Scatterv``
+* ``MPI_Send``, ``MPI_Send_init``
+* ``MPI_Sendrecv``
+* ``MPI_Ssend``, ``MPI_Ssend_init``
+* ``MPI_Win_create``
+
+The following operations do *not* currently accept CUDA device buffers:
+
+* ``MPI_Accumulate``, ``MPI_Get_Accumulate``
+* ``MPI_Compare_and_swap``, ``MPI_Fetch_and_op``
+* The non-blocking collectives ``MPI_Iallgather``, ``MPI_Iallgatherv``,
+  ``MPI_Iallreduce``, ``MPI_Ialltoall``, ``MPI_Ialltoallv``,
+  ``MPI_Ialltoallw``, ``MPI_Ibcast``, and ``MPI_Iexscan``
+* ``MPI_Rget``, ``MPI_Rput``
+
+.. note:: These lists reflect known support and may vary between Open
+   MPI versions and transports.  The set of CUDA-aware operations when
+   using the UCX PML is essentially the same as above, with the
+   additional restriction that UCX's one-sided component does not
+   support CUDA buffers: all one-sided operations (for example,
+   ``MPI_Put``, ``MPI_Get``, ``MPI_Accumulate``), all window creation
+   calls (for example, ``MPI_Win_create``), and all non-blocking
+   reduction collectives are not CUDA-aware when using UCX.
+
+Transport-specific notes
+------------------------
+
+CUDA-aware UCX
+^^^^^^^^^^^^^^
+
+When both UCX and Open MPI are built with CUDA support, selecting the
+UCX PML is sufficient to use it.  For example, to run ``osu_latency``
+from the `OSU benchmarks <https://mvapich.cse.ohio-state.edu/benchmarks>`_
+with CUDA buffers:
 
-  .. code-block:: sh
+.. code-block:: sh
 
-     shell$ mpirun --mca btl_smcuda_use_cuda_ipc 0 ...
+   shell$ mpirun -n 2 --mca pml ucx \
+       -x UCX_TLS=rc,sm,cuda_copy,gdr_copy,cuda_ipc ./osu_latency D D
 
-  In addition, it is assumed that CUDA IPC is possible when running on
-  the same GPU, and this is typically true.  However, there is the
-  ability to turn it off.
+OFI / libfabric
+^^^^^^^^^^^^^^^
+
+When running over Libfabric, the OFI MTL checks whether any provider
+can handle GPU (or other accelerator) memory through the
+``hmem``-related flags.  If a CUDA-capable provider is available, the
+OFI MTL sends GPU buffers directly through Libfabric's API after
+registering the memory; otherwise, the buffers are automatically copied
+to host memory before being transferred.
+
+PSM2 / Omni-Path
+^^^^^^^^^^^^^^^^^^
+
+CUDA-aware support is present in the PSM2 MTL.  When running CUDA-aware
+Open MPI on Cornelis Networks Omni-Path, the PSM2 MTL automatically sets
+the ``PSM2_CUDA`` environment variable so that PSM2 handles GPU
+buffers.  If you want to use host buffers with a CUDA-aware Open MPI, it
+is recommended to set ``PSM2_CUDA`` to ``0`` in the environment.  PSM2
+also supports NVIDIA GPUDirect; to enable it, set ``PSM2_GPUDIRECT`` to
+``1``.  These variables must be set before ``MPI_Init()`` is called, for
+example:
 
-  .. code-block:: sh
+.. code-block:: sh
 
-     shell$ mpirun --mca btl_smcuda_use_cuda_ipc_same_gpu 0 ...
+   shell$ mpirun -x PSM2_CUDA=1 -x PSM2_GPUDIRECT=1 --mca mtl psm2 ./mpi_hello
+
+GPUDirect support on Omni-Path requires a PSM2 library and ``hfi1``
+driver with CUDA support; the minimum required PSM2 version is `PSM2
+10.2.175 <https://github.com/01org/opa-psm2/releases/tag/PSM2_10.2-175>`_.
+
+When binding processes to GPUs on Omni-Path, each process should select
+a specific GPU (within the same NUMA node as the CPU the process runs
+on) before calling ``MPI_Init()`` using ``cudaChooseDevice()``,
+``cudaSetDevice()``, and similar; use the ``mpirun`` binding options
+(such as ``--bind-to core``) to keep processes from migrating between
+NUMA nodes.  See :ref:`Selecting a GPU close to the process
+<faq-cuda-mpi-cuda-numa-issues-label>`.
+
+.. note:: The Cornelis Networks Omni-Path / PSM2 details above may be
+   dated.  For current guidance, consult the PSM2 and Omni-Path
+   documentation from `Cornelis Networks
+   <https://customercenter.cornelisnetworks.com/>`_.
+
+Selecting a CUDA device
+-----------------------
+
+Open MPI requires some CUDA resources for internal use.  When possible,
+these are allocated lazily, the first time they are needed |mdash| for
+example, CUDA IPC memory handles are created when a transfer first
+requires them.  ``MPI_Init()`` and most communicator operations do not
+create any CUDA resources (this is guaranteed at least for
+``MPI_Comm_rank`` and ``MPI_Comm_size`` on ``MPI_COMM_WORLD``).
+
+This is not always the case, however.  When using PSM2 or the
+``smcuda`` BTL (with the OB1 PML), it is not feasible to delay the
+allocation, so those CUDA resources are allocated during
+``MPI_Init()``.
+
+In all cases, the CUDA device must be selected *before* the first MPI
+call that requires a CUDA resource.  When CUDA resources are initialized
+lazily, you may use the communicator operations above to determine rank
+information and select a GPU accordingly:
 
-  Last, to get some insight into whether CUDA IPC is being used, you
-  can turn on some verbosity that shows whether CUDA IPC gets enabled
-  between two GPUs.
+.. code-block:: c
 
-  .. code-block:: sh
+   int local_rank = -1;
+   {
+       MPI_Comm local_comm;
+       MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, rank,
+                           MPI_INFO_NULL, &local_comm);
+       MPI_Comm_rank(local_comm, &local_rank);
+       MPI_Comm_free(&local_comm);
+   }
+   int num_devices = 0;
+   cudaGetDeviceCount(&num_devices);
+   cudaSetDevice(local_rank % num_devices);
 
-     shell$ mpirun --mca btl_smcuda_cuda_ipc_verbose 100 ...
+Open MPI's internal CUDA resources are released during
+``MPI_Finalize()``, so it is an application error to call
+``cudaDeviceReset()`` before ``MPI_Finalize()``.
 
-/////////////////////////////////////////////////////////////////////////
+For a general treatment of selecting an accelerator device before
+``MPI_Init()`` (using the ``OMPI_COMM_WORLD_LOCAL_RANK`` environment
+variable), see :doc:`initialize`.
 
 .. _faq-cuda-mpi-cuda-numa-issues-label:
 
-NUMA Node Issues
-----------------
+Selecting a GPU close to the process
+------------------------------------
 
-When running on a node that has multiple GPUs, you may want to select
-the GPU that is closest to the NUMA node on which your process is
-running.  One way to do this is to make use of the ``hwloc`` library.
-The following is a C code snippet that can be used in your application
-to select a GPU that is close.  It will determine on which CPU it is
-running and then look for the closest GPU.  There could be multiple
-GPUs that are the same distance away.  This is dependent on having
-``hwloc`` somewhere on your system.
+On a node with multiple GPUs, you may want each process to use the GPU
+closest to the NUMA node on which it is running.  One way to do this is
+with the ``hwloc`` library.  The following C snippet determines the CPU
+the process is running on and then looks for the closest GPU; note that
+several GPUs may be equidistant.
 
 .. code-block:: c
 
@@ -268,7 +356,6 @@ GPUs that are the same distance away.  This is dependent on having
     * that the MPI program is running on.  Note that this works even without
     * any libpciaccess or libpci support as it keys off the NVIDIA vendor ID.
     * There may be other ways to implement this but this is one way.
-    * January 10, 2014
     */
    #include <assert.h>
    #include <stdio.h>
@@ -375,329 +462,90 @@ GPUs that are the same distance away.  This is dependent on having
        return 0;
    }
 
-/////////////////////////////////////////////////////////////////////////
+Run-time tuning and debugging
+-----------------------------
 
-How do I develop CUDA-aware Open MPI applications?
---------------------------------------------------
+CUDA IPC in the shared-memory BTL
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Developing CUDA-aware applications is a complex topic, and beyond the
-scope of this document. CUDA-aware applications often have to take
-machine-specific considerations into account, including the number of
-GPUs installed on each node and how the GPUs are connected to the CPUs
-and to each other. Often, when using a particular transport layer
-(such as OPA/PSM2) there will be run-time decisions to make about
-which CPU cores will be used with which GPUs.
+By default, the ``smcuda`` BTL uses CUDA IPC where possible to move GPU
+data quickly between GPUs on the same node and PCI root complex.  A few
+MCA parameters control this behavior.  You can disable CUDA IPC
+entirely:
 
-A good place to start is the `NVIDIA CUDA Toolkit Documentation
-<https://docs.nvidia.com/cuda/>`_ including the `Programming Guide
-<https://docs.nvidia.com/cuda/cuda-c-programming-guide/>`_ and the
-`Best Practices Guide
-<https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/>`_.  For
-examples of how to write CUDA-aware MPI applications, the `NVIDIA
-developers blog
-<https://github.com/NVIDIA-developer-blog/code-samples/tree/master/posts/cuda-aware-mpi-example>`_
-offers examples and the `OSU Micro-Benchmarks
-<https://mvapich.cse.ohio-state.edu/benchmarks/>`_ offer an excellent
-example of how to write CUDA-aware MPI applications.
-
-/////////////////////////////////////////////////////////////////////////
-
-.. _faq-cuda-mpi-apis-cuda-label:
-
-Which MPI APIs work with CUDA-aware?
-------------------------------------
-
-* MPI_Allgather
-* MPI_Allgatherv
-* MPI_Allreduce
-* MPI_Alltoall
-* MPI_Alltoallv
-* MPI_Alltoallw
-* MPI_Bcast
-* MPI_Bsend
-* MPI_Bsend_init
-* MPI_Exscan
-* MPI_Ibsend
-* MPI_Irecv
-* MPI_Isend
-* MPI_Irsend
-* MPI_Issend
-* MPI_Gather
-* MPI_Gatherv
-* MPI_Get
-* MPI_Put
-* MPI_Rsend
-* MPI_Rsend_init
-* MPI_Recv
-* MPI_Recv_init
-* MPI_Reduce
-* MPI_Reduce_scatter
-* MPI_Reduce_scatter_block
-* MPI_Scan
-* MPI_Scatter
-* MPI_Scatterv
-* MPI_Send
-* MPI_Send_init
-* MPI_Sendrecv
-* MPI_Ssend
-* MPI_Ssend_init
-* MPI_Win_create
-
-.. FIXME: We need to verify the above list.
-
-/////////////////////////////////////////////////////////////////////////
-
-Which MPI APIs do NOT work with CUDA-aware?
--------------------------------------------
-
-* MPI_Accumulate
-* MPI_Compare_and_swap
-* MPI_Fetch_and_op
-* MPI_Get_Accumulate
-* MPI_Iallgather
-* MPI_Iallgatherv
-* MPI_Iallreduce
-* MPI_Ialltoall
-* MPI_Ialltoallv
-* MPI_Ialltoallw
-* MPI_Ibcast
-* MPI_Iexscan
-* MPI_Rget
-* MPI_Rput
-
-.. FIXME: We need to verify the above list.
-
-/////////////////////////////////////////////////////////////////////////
-
-How do I use CUDA-aware UCX for Open MPI?
------------------------------------------
-
-Example of running ``osu_latency`` from the `OSU benchmarks
-<https://mvapich.cse.ohio-state.edu/benchmarks>`_ with CUDA buffers
-using Open MPI and UCX CUDA support:
-
-.. code-block::
-
-   shell$ mpirun -n 2 --mca pml ucx \
-       -x UCX_TLS=rc,sm,cuda_copy,gdr_copy,cuda_ipc ./osu_latency D D
-
-/////////////////////////////////////////////////////////////////////////
-
-Which MPI APIs work with CUDA-aware UCX?
-----------------------------------------
-
-* MPI_Send
-* MPI_Bsend
-* MPI_Ssend
-* MPI_Rsend
-* MPI_Isend
-* MPI_Ibsend
-* MPI_Issend
-* MPI_Irsend
-* MPI_Send_init
-* MPI_Bsend_init
-* MPI_Ssend_init
-* MPI_Rsend_init
-* MPI_Recv
-* MPI_Irecv
-* MPI_Recv_init
-* MPI_Sendrecv
-* MPI_Bcast
-* MPI_Gather
-* MPI_Gatherv
-* MPI_Allgather
-* MPI_Reduce
-* MPI_Reduce_scatter
-* MPI_Reduce_scatter_block
-* MPI_Allreduce
-* MPI_Scan
-* MPI_Exscan
-* MPI_Allgatherv
-* MPI_Alltoall
-* MPI_Alltoallv
-* MPI_Alltoallw
-* MPI_Scatter
-* MPI_Scatterv
-* MPI_Iallgather
-* MPI_Iallgatherv
-* MPI_Ialltoall
-* MPI_Iialltoallv
-* MPI_Ialltoallw
-* MPI_Ibcast
-* MPI_Iexscan
-
-.. FIXME: We need to verify the above list.  These _SHOULD_ be the same
-   as above.
-
-/////////////////////////////////////////////////////////////////////////
-
-Which MPI APIs do NOT work with CUDA-aware UCX?
------------------------------------------------
-
-* All one-sided operations such as MPI_Put, MPI_Get, MPI_Accumulate,
-  MPI_Rget, MPI_Rput, MPI_Get_Accumulate, MPI_Fetch_and_op,
-  MPI_Compare_and_swap, etc
-* All window creation calls such as MPI_Win_create
-* All non-blocking reduction collectives like MPI_Ireduce,
-  MPI_Iallreduce, etc
-
-.. FIXME: Checking with nVidia.  This may be more of an issue of OSC_UCX
-   not supporting CUDA, though perhaps it's just performance.
-
-/////////////////////////////////////////////////////////////////////////
-
-Can I tell at compile time or runtime whether I have CUDA-aware support?
-------------------------------------------------------------------------
-
-There is both a compile time check and a run-time check available.
-You can use whichever is the most convenient for your program.  To
-access them, you need to include ``mpi-ext.h``. Note that
-``mpi-ext.h`` is specific to Open MPI. The following program shows an
-example of using the CUDA-aware macro and run-time check.
-
-.. code-block:: c
-
-   /*
-    * Program that shows the use of CUDA-aware macro and runtime check.
-    */
-   #include <stdio.h>
-   #include "mpi.h"
-
-   #if !defined(OPEN_MPI) || !OPEN_MPI
-   #error This source code uses an Open MPI-specific extension
-   #endif
+.. code-block:: sh
 
-   /* Needed for MPIX_Query_cuda_support(), below */
-   #include "mpi-ext.h"
+   shell$ mpirun --mca btl_smcuda_use_cuda_ipc 0 ...
 
-   int main(int argc, char *argv[])
-   {
-       MPI_Init(&argc, &argv);
-
-       printf("Compile time check:\n");
-   #if defined(MPIX_CUDA_AWARE_SUPPORT) && MPIX_CUDA_AWARE_SUPPORT
-       printf("This MPI library has CUDA-aware support.\n", MPIX_CUDA_AWARE_SUPPORT);
-   #elif defined(MPIX_CUDA_AWARE_SUPPORT) && !MPIX_CUDA_AWARE_SUPPORT
-       printf("This MPI library does not have CUDA-aware support.\n");
-   #else
-       printf("This MPI library cannot determine if there is CUDA-aware support.\n");
-   #endif /* MPIX_CUDA_AWARE_SUPPORT */
+CUDA IPC is assumed to be possible when two ranks run on the same GPU;
+this too can be disabled:
 
-       printf("Run time check:\n");
-   #if defined(MPIX_CUDA_AWARE_SUPPORT)
-       if (1 == MPIX_Query_cuda_support()) {
-           printf("This MPI library has CUDA-aware support.\n");
-       } else {
-           printf("This MPI library does not have CUDA-aware support.\n");
-       }
-   #else /* !defined(MPIX_CUDA_AWARE_SUPPORT) */
-       printf("This MPI library cannot determine if there is CUDA-aware support.\n");
-   #endif /* MPIX_CUDA_AWARE_SUPPORT */
+.. code-block:: sh
 
-       MPI_Finalize();
+   shell$ mpirun --mca btl_smcuda_use_cuda_ipc_same_gpu 0 ...
 
-       return 0;
-   }
+To see whether CUDA IPC is being enabled between two GPUs, turn on some
+verbosity:
 
-/////////////////////////////////////////////////////////////////////////
+.. code-block:: sh
 
-How do I limit how much CUDA IPC memory is held in the registration cache?
---------------------------------------------------------------------------
+   shell$ mpirun --mca btl_smcuda_cuda_ipc_verbose 100 ...
 
-As mentioned earlier, the Open MPI library will make use of CUDA IPC support where
-possible to move the GPU data quickly between GPUs that are on the same node and
-same PCI root complex. The library holds on to registrations even after the data
-transfer is complete as it is expensive to make some of the CUDA IPC registration
-calls. If you want to limit how much memory is registered, you can use the
-``mpool_rgpusm_rcache_size_limit`` MCA parameter. For example, this sets the limit
-to 1000000 bytes:
+The ``smcuda`` BTL holds on to CUDA IPC registrations even after a
+transfer completes, because the registration calls are expensive.  To
+limit how much memory is registered, use the
+``mpool_rgpusm_rcache_size_limit`` MCA parameter (in bytes); when the
+cache reaches this size, the least-recently-used entries are evicted to
+make room:
 
-.. code-block::
+.. code-block:: sh
 
    shell$ mpirun --mca mpool_rgpusm_rcache_size_limit 1000000 ...
 
-When the cache reaches this size, it will kick out the least recently used until
-it can fit the new registration in.
-
-There also is the ability to have the cache empty itself out when the
-limit is reached:
+Alternatively, the cache can empty itself entirely when the limit is
+reached:
 
-.. code-block::
+.. code-block:: sh
 
    shell$ mpirun --mca mpool_rgpusm_rcache_empty_cache 1 ...
 
-/////////////////////////////////////////////////////////////////////////
-
-What are some guidelines for using CUDA and Open MPI with Omni-Path?
---------------------------------------------------------------------
-
-When developing CUDA-aware Open MPI applications for OPA-based fabrics, the
-PSM2 transport is preferred and a CUDA-aware version of PSM2 is provided with
-all versions of the Cornelis Networks Omni-Path OPXS software suite.
-
-.. error:: TODO Are Intel/OPA references still correct?
-
-The PSM2 library provides a number of settings that will govern how it
-will interact with CUDA, including ``PSM2_CUDA`` and ``PSM2_GPUDIRECT``,
-which should be set in the environment before ``MPI_Init()`` is called. For
-example:
-
-.. code-block::
+Verbose output
+^^^^^^^^^^^^^^
 
-   shell$ mpirun -x PSM2_CUDA=1 -x PSM2_GPUDIRECT=1 --mca mtl psm2 mpi_hello
+Additional CUDA debugging output is available at run time.  The
+``opal_cuda_verbose`` parameter has a single verbosity level:
 
-In addition, each process of the application should select a specific
-GPU card to use before calling ``MPI_Init()``, by using
-``cudaChooseDevice()``, ``cudaSetDevice()`` and similar. The chosen
-GPU should be within the same NUMA node as the CPU the MPI process is
-running on. You will also want to use the ``mpirun``
-``--bind-to-core`` or ``--bind-to-socket`` option to ensure that MPI
-processes do not move between NUMA nodes. See the section on
-:ref:`NUMA Node Issues <faq-cuda-mpi-cuda-numa-issues-label>`, for
-more information.
-
-For more information see the *Cornelis Networks Performance Scaled Messaging 2
-(PSM2) Programmer's Guide* and the *Cornelis Networks Omni-Path Performance
-Tuning Guide*, which can be found in the `Cornelis Networks Customer Center
-<https://customercenter.cornelisnetworks.com/>`_.
-
-.. error:: TODO Are Intel/OPA references still correct?
+.. code-block:: sh
 
-/////////////////////////////////////////////////////////////////////////
+   shell$ mpirun --mca opal_cuda_verbose 10 ...
 
-When do I need to select a CUDA device?
----------------------------------------
+The ``mpi_common_cuda_verbose`` parameter provides more detailed
+information about CUDA-aware activities and accepts a range of values.
+There is normally no need to use these unless you are diagnosing a
+problem:
 
-Open MPI requires CUDA resources allocated for internal use. When possible,
-these resources are allocated lazily when they are first needed, e.g. CUDA
-IPC mem handles are created when a communication routine first requires them
-during a transfer.  MPI_Init and most communicator related operations do not
-create any CUDA resources (guaranteed at least for MPI_Comm_rank,
-MPI_Comm_size on ``MPI_COMM_WORLD``).
+.. code-block:: sh
 
-However, this is not always the case. In certain instances, such as when
-using PSM2 or the ``smcuda`` BTL (with the OB1 PML), it is not feasible to
-delay the CUDA resources allocation. Consequently, these resources will need
-to be allocated during ``MPI_Init()``.
+   shell$ mpirun --mca mpi_common_cuda_verbose 10 ...    # some detail
+   shell$ mpirun --mca mpi_common_cuda_verbose 20 ...    # more detail
+   shell$ mpirun --mca mpi_common_cuda_verbose 100 ...   # most detail
 
-Regardless of the situation, the CUDA device must be selected before the first
-MPI call that requires a CUDA resource. When CUDA resources can be initialized
-lazily, it is possible to use the aforementioned communicator-related operations
-to query rank information and utilize that to select a GPU.
+Developing CUDA-aware applications
+----------------------------------
 
+Developing CUDA-aware applications is a broad topic, beyond the scope of
+this document.  Such applications often must account for
+machine-specific details, including the number of GPUs per node and how
+the GPUs are connected to the CPUs and to each other.  With some
+transports there are additional run-time decisions to make about which
+CPU cores are used with which GPUs.
 
-.. code-block:: c
-
-    int local_rank = -1;
-    {
-        MPI_Comm local_comm;
-        MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, rank, MPI_INFO_NULL, &local_comm);
-        MPI_Comm_rank(local_comm, &local_rank);
-        MPI_Comm_free(&local_comm);
-    }
-    int num_devices = 0;
-    cudaGetDeviceCount(&num_devices);
-    cudaSetDevice(local_rank % num_devices);
-
-MPI internal CUDA resources are released during MPI_Finalize. Thus it is an
-application error to call cudaDeviceReset before MPI_Finalize is called.
+A good place to start is the `NVIDIA CUDA Toolkit Documentation
+<https://docs.nvidia.com/cuda/>`_, including the `Programming Guide
+<https://docs.nvidia.com/cuda/cuda-c-programming-guide/>`_ and the `Best
+Practices Guide
+<https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/>`_.  For
+examples of CUDA-aware MPI applications, the `NVIDIA developer blog
+<https://github.com/NVIDIA-developer-blog/code-samples/tree/master/posts/cuda-aware-mpi-example>`_
+and the `OSU Micro-Benchmarks
+<https://mvapich.cse.ohio-state.edu/benchmarks/>`_ are good references.
diff --git a/docs/tuning-apps/accelerators/memkind.rst b/docs/tuning-apps/accelerators/memkind.rst
index 7567d9f7e82..e414af4eacc 100644
--- a/docs/tuning-apps/accelerators/memkind.rst
+++ b/docs/tuning-apps/accelerators/memkind.rst
@@ -48,7 +48,7 @@ information to Open MPI at application launch:
 Asserting usage of memory kind when creating a Communicator
 ===========================================================
 
-The following code-snipplet demonstrates how to assert that a
+The following code snippet demonstrates how to assert that a
 communicator will only be used for ROCm device buffers:
 
 .. code:: c
diff --git a/docs/tuning-apps/accelerators/rocm.rst b/docs/tuning-apps/accelerators/rocm.rst
index b19ad98bb6d..5c78f78ef78 100644
--- a/docs/tuning-apps/accelerators/rocm.rst
+++ b/docs/tuning-apps/accelerators/rocm.rst
@@ -255,7 +255,7 @@ An example for configure UCC and Open MPI with ROCm is shown below:
                       --with-ucx=/path/to/ucx-rocm-install \
                       --with-ucc=/path/to/ucc-rocm-install
 
-To use the UCC component in an application requires setting some
+Using the UCC component in an application requires setting some
 additional parameters:
 
 .. code-block::
diff --git a/docs/tuning-apps/benchmarking.rst b/docs/tuning-apps/benchmarking.rst
index 0a555a2fdbb..caff1d79340 100644
--- a/docs/tuning-apps/benchmarking.rst
+++ b/docs/tuning-apps/benchmarking.rst
@@ -8,7 +8,7 @@ This documentation is by no means a definitive guide, but it does try
 to offer some suggestions for generating accurate, meaningful
 benchmarks.
 
-#. Decide *exactly* what you are benchmarking and setup your system
+#. Decide *exactly* what you are benchmarking and set up your system
    accordingly.  For example, if you are trying to benchmark maximum
    performance, then many of the suggestions listed below are
    extremely relevant (be the only user on the systems and network in
@@ -82,7 +82,7 @@ benchmarks.
 
    * Perform some "warmup" events first.  Many MPI implementations
      (including Open MPI) |mdash| and other subsystems upon which the
-     MPI uses |mdash| may use "lazy" semantics to setup and maintain
+     MPI uses |mdash| may use "lazy" semantics to set up and maintain
      streams of communications.  Hence, the first event (or first few
      events) may well take significantly longer than subsequent
      events.
@@ -108,4 +108,3 @@ benchmarks.
    system configuration that you are benchmarking.  Note, for example,
    all hardware and software characteristics (to include hardware,
    firmware, and software versions as appropriate).
-
diff --git a/docs/tuning-apps/collectives/components.rst b/docs/tuning-apps/collectives/components.rst
index 921f7e12036..b828d9861ad 100644
--- a/docs/tuning-apps/collectives/components.rst
+++ b/docs/tuning-apps/collectives/components.rst
@@ -2,7 +2,7 @@ Available Collective Components
 ===============================
 
 Open MPI's ``coll`` framework provides a number of components
-implementing collective communication, each of which target a
+implementing collective communication, each of which targets a
 different environment or scenario.  Some of these components may not
 be available depending on how Open MPI was compiled and what hardware
 is available on the system.  A run-time decision based on each
@@ -27,7 +27,7 @@ The following provides a list of components and their primary target scenario:
    between algorithms for each operation and message size. See :doc:`tuned` for
    more details.
  - ``ucc``: component using the `UCC library <https://github.com/openucx/ucc/>`_
-   for collective operations.
+   for collective operations. See :doc:`ucc` for more details.
  - ``xhc``: shared memory collective component, employing hierarchical &
    topology-aware algorithms, with XPMEM for data transfers. See :doc:`xhc` for
    more details.
@@ -36,13 +36,13 @@ The following provides a list of components and their primary target scenario:
  - ``accelerator``: component providing host-proxy algorithms for some
    collective operations using device buffers.
  - ``ftagree``: component providing fault-tolerant collective operations.
- - ``inter``: component providing collective operaitons for inter-communicators.
+ - ``inter``: component providing collective operations for inter-communicators.
  - ``basic``: component providing basic algorithms, used as a fall-back component.
  - ``sync``: component used in scenarios where some nodes can be
    overrun with messages. This component can be used to insert
    synchronization points every *n-th* execution of a collective
    operations.
- - ``portals4``: component targetting portals4 networks.
+ - ``portals4``: component targeting portals4 networks.
 
 Different component can and will be used for different collective
 operations, since no component is providing implementations for all
diff --git a/docs/tuning-apps/collectives/index.rst b/docs/tuning-apps/collectives/index.rst
index 2e49cae2d15..be30b5a574c 100644
--- a/docs/tuning-apps/collectives/index.rst
+++ b/docs/tuning-apps/collectives/index.rst
@@ -2,7 +2,7 @@ Collective operations
 =====================
 
 Open MPI provides a number of components implementing collective
-operations and significant flexbility to tune collective operations.
+operations and significant flexibility to tune collective operations.
 This section documents the available components and gives for some
 components additional information on how to utilize them.
 
@@ -11,5 +11,6 @@ components additional information on how to utilize them.
 
    components
    tuned
+   ucc
    acoll
    xhc
diff --git a/docs/tuning-apps/collectives/ucc.rst b/docs/tuning-apps/collectives/ucc.rst
new file mode 100644
index 00000000000..e212aa5ff74
--- /dev/null
+++ b/docs/tuning-apps/collectives/ucc.rst
@@ -0,0 +1,173 @@
+The ``ucc`` Component
+=====================
+
+The ``ucc`` collective component uses the `Unified Collective
+Communication (UCC) library <https://github.com/openucx/ucc/>`_ to
+offload selected MPI collective operations to UCC.  This component is
+useful on systems where UCC has been configured for the target transport
+or accelerator environment.
+
+Building with UCC
+-----------------
+
+Open MPI must be configured with UCC support:
+
+.. code-block:: sh
+
+   shell$ ./configure --with-ucc=/path/to/ucc-install
+
+If UCC support is explicitly requested and the UCC headers and library
+cannot be found, ``configure`` aborts.  The ``ucc`` component is disabled
+when Open MPI is configured with progress thread support, because the UCC
+driver does not currently support progress threads.
+
+Enabling the Component
+----------------------
+
+The component is not enabled by default.  Enable it at run time and give
+it a high enough priority to be selected:
+
+.. code-block:: sh
+
+   shell$ mpirun --mca coll_ucc_enable 1 \
+                 --mca coll_ucc_priority 100 \
+                 -np 64 ./my_mpi_app
+
+The ``ucc`` component is considered only for intracommunicators whose
+size is at least ``coll_ucc_np``.  The default value of ``coll_ucc_np``
+is ``2``.
+
+UCC Layers and Protocols
+------------------------
+
+For each MPI communicator selected for UCC, Open MPI creates a UCC
+``team``: the UCC group object used to initialize and execute collective
+operations.  Inside UCC, collective implementations are selected through
+two kinds of layers:
+
+* Collective layers (CLs), such as ``basic`` and ``hier``, decide how a
+  collective is decomposed.
+* Team layers (TLs), such as ``ucp``, ``self``, ``cuda``, ``nccl``,
+  ``rccl``, ``sharp``, and ``mlx5``, provide the underlying transport or
+  accelerator implementation.
+
+For example, the ``ucp`` TL uses UCX/UCP transports such as InfiniBand,
+RoCE, and shared memory; ``sharp`` uses SHARP in-network collective
+offload; and ``nccl`` or ``rccl`` can be used for GPU collectives on
+CUDA or ROCm memory.
+
+The ``basic`` CL is the general-purpose layer.  The ``hier`` CL can use
+system hierarchy when it is available; for example, it may split work
+across ``NODE`` and ``NET`` subgroups, plus the ``FULL`` group, and then
+pipeline phases through different TLs.  A typical hierarchical protocol
+could use an intra-node reduction, an inter-node operation such as
+SHARP, and an intra-node broadcast.
+
+The exact CLs, TLs, and algorithms available depend on how UCC was
+built.  Use UCC's own tools to inspect the installed library:
+
+.. code-block:: sh
+
+   shell$ ucc_info -s   # Show available CLs and TLs
+   shell$ ucc_info -A   # Show supported collective algorithms
+   shell$ ucc_info -caf # Show UCC configuration variables
+
+Open MPI's ``coll_ucc_cls`` MCA parameter is passed to UCC as its
+``CLS`` setting.  It can be used to restrict team creation to specific
+UCC collective layers, for example:
+
+.. code-block:: sh
+
+   shell$ mpirun --mca coll_ucc_enable 1 \
+                 --mca coll_ucc_cls hier \
+                 ./my_mpi_app
+
+For lower-level TL tuning, use UCC environment variables such as
+``UCC_TL_<NAME>_TUNE`` or a UCC configuration file.  UCC scores TLs
+based on factors including the collective type, message size, memory
+type, and team size.
+
+Selecting Collective Operations
+-------------------------------
+
+Use ``coll_ucc_cts`` to choose which collective operations the component
+should provide.  By default, the component enables all supported blocking
+and nonblocking operations.
+
+.. code-block:: sh
+
+   shell$ mpirun --mca coll_ucc_enable 1 \
+                 --mca coll_ucc_cts allreduce,iallreduce,bcast,ibcast \
+                 ./my_mpi_app
+
+Prefix the value with ``^`` to start from all supported operations and
+disable specific operations from that set:
+
+.. code-block:: sh
+
+   shell$ mpirun --mca coll_ucc_enable 1 \
+                 --mca coll_ucc_cts ^alltoall,ialltoall \
+                 ./my_mpi_app
+
+The supported operation names are:
+
+* ``barrier``, ``bcast``, ``allreduce``, ``alltoall``, ``alltoallv``,
+  ``allgather``, ``allgatherv``, ``reduce``, ``gather``, ``gatherv``,
+  ``reduce_scatter_block``, ``reduce_scatter``, ``scatterv``, and
+  ``scatter``
+* ``ibarrier``, ``ibcast``, ``iallreduce``, ``ialltoall``,
+  ``ialltoallv``, ``iallgather``, ``iallgatherv``, ``ireduce``,
+  ``igather``, ``igatherv``, ``ireduce_scatter_block``,
+  ``ireduce_scatter``, ``iscatterv``, and ``iscatter``
+
+The aliases ``colls_b``, ``colls_i`` (or ``colls_nb``), and ``colls_p``
+select all blocking, nonblocking, and persistent collective operations,
+respectively.  Individual persistent collective operations can be
+selected by adding the ``_init`` suffix to the blocking operation name,
+for example ``allreduce_init``.
+
+Other MCA Parameters
+--------------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 15 55
+
+   * - Parameter
+     - Default
+     - Description
+   * - ``coll_ucc_enable``
+     - ``0``
+     - Enable or disable the component.
+   * - ``coll_ucc_priority``
+     - ``10``
+     - Component selection priority.
+   * - ``coll_ucc_verbose``
+     - ``0``
+     - Verbosity level for component logging.
+   * - ``coll_ucc_np``
+     - ``2``
+     - Minimum communicator size for enabling the component.
+   * - ``coll_ucc_cls``
+     - UCC default
+     - Comma-separated list of UCC collective layers to use for team
+       creation, passed to UCC as ``CLS``.
+   * - ``coll_ucc_cts``
+     - All supported blocking and nonblocking operations
+     - Comma-separated list of UCC collective types to enable.
+
+Verifying Selection
+-------------------
+
+Use ``coll_base_verbose`` to check which collective component Open MPI
+selects for each operation:
+
+.. code-block:: sh
+
+   shell$ mpirun --mca coll_ucc_enable 1 \
+                 --mca coll_ucc_priority 100 \
+                 --mca coll_base_verbose 20 \
+                 ./my_mpi_app
+
+See :doc:`components` for more details about interpreting collective
+component selection output.
diff --git a/docs/tuning-apps/collectives/xhc.rst b/docs/tuning-apps/collectives/xhc.rst
index 8ac345649c5..a74d81698f0 100644
--- a/docs/tuning-apps/collectives/xhc.rst
+++ b/docs/tuning-apps/collectives/xhc.rst
@@ -167,7 +167,7 @@ Main
    * - coll_xhc_<op>_hierarchy
      - bcast/barrier: ``numa,socket``
        (all)reduce: ``l3,numa,socket``
-     - Topological features to consider for XHC's hierarchy, specifially for
+     - Topological features to consider for XHC's hierarchy, specifically for
        this primitive. Mutually exclusive with the respective non-specific
        parameter.
    
diff --git a/docs/tuning-apps/fault-tolerance/checkpoint-restart.rst b/docs/tuning-apps/fault-tolerance/checkpoint-restart.rst
index d904c7b1efa..248be721a80 100644
--- a/docs/tuning-apps/fault-tolerance/checkpoint-restart.rst
+++ b/docs/tuning-apps/fault-tolerance/checkpoint-restart.rst
@@ -7,7 +7,7 @@ Old versions of Open MPI (starting from v1.3 series) had support for
 the transparent, coordinated checkpointing and restarting of MPI
 processes (similar to LAM/MPI).
 
-Open MPI supported both the the `BLCR <http://ftg.lbl.gov/checkpoint/>`_
+Open MPI supported both the `BLCR <http://ftg.lbl.gov/checkpoint/>`_
 checkpoint/restart system and a "self" checkpointer that allows
 applications to perform their own checkpoint/restart functionality while taking
 advantage of the Open MPI checkpoint/restart infrastructure.
diff --git a/docs/tuning-apps/large-clusters/index.rst b/docs/tuning-apps/large-clusters/index.rst
index ff58b2b7e13..8ed80bb842b 100644
--- a/docs/tuning-apps/large-clusters/index.rst
+++ b/docs/tuning-apps/large-clusters/index.rst
@@ -5,6 +5,10 @@ Setting up a large cluster to run MPI applications can be challenging and
 full of many decisions.  The following sections include guidance for
 installing and tuning Open MPI on large clusters.
 
+Also see :doc:`Deciding what to install
+</installing-open-mpi/configure-cli-options/what-to-install>` for
+build-time considerations that can affect large-cluster deployments.
+
 .. toctree::
    :maxdepth: 1
 
diff --git a/docs/tuning-apps/large-clusters/libraries.rst b/docs/tuning-apps/large-clusters/libraries.rst
index 8673c45de14..8e53e9d04d0 100644
--- a/docs/tuning-apps/large-clusters/libraries.rst
+++ b/docs/tuning-apps/large-clusters/libraries.rst
@@ -24,7 +24,7 @@ place the Open MPI libraries on networked file systems:
   cluster!  Doing so will lead to significant network traffic and
   delayed start times, especially on clusters with a large number of
   nodes.  Instead, be sure to :ref:`configure your build
-  <building-ompi-cli-options-diable-dlopen-label>` with
+  <building-ompi-cli-options-disable-dlopen-label>` with
   ``--disable-dlopen``.  This will include the DSO's in the main
   libraries, resulting in much faster startup times.
 
diff --git a/docs/tuning-apps/large-clusters/reduce-startup-time.rst b/docs/tuning-apps/large-clusters/reduce-startup-time.rst
index 01751330bf6..e72697777ef 100644
--- a/docs/tuning-apps/large-clusters/reduce-startup-time.rst
+++ b/docs/tuning-apps/large-clusters/reduce-startup-time.rst
@@ -1,8 +1,6 @@
 Reducing startup time for jobs
 ==============================
 
-.. error:: TODO This whole section needs to be checked.
-
 There are several ways to reduce the startup time on large
 clusters. Some of them are described on this page. We continue to work
 on making startup even faster, especially on the large clusters coming
diff --git a/docs/tuning-apps/large-clusters/reduce-wireup-time.rst b/docs/tuning-apps/large-clusters/reduce-wireup-time.rst
index 349f0500a77..1634b362334 100644
--- a/docs/tuning-apps/large-clusters/reduce-wireup-time.rst
+++ b/docs/tuning-apps/large-clusters/reduce-wireup-time.rst
@@ -2,32 +2,67 @@ Reducing wireup time
 ====================
 
 Open MPI's run-time uses an *out-of-band* (OOB) communication
-subsystem to pass messages during the launch, initialization, and
-termination stages for the job. These messages allow ``mpirun`` to tell
-its daemons what processes to launch, and allow the daemons in turn to
-forward stdio to ``mpirun``, update ``mpirun`` on process status, etc.
-
-The OOB uses TCP sockets for its communication, with each daemon
-opening a socket back to ``mpirun`` upon startup. In a large cluster,
-this can mean thousands of connections being formed on the node where
-``mpirun`` resides, and requires that ``mpirun`` actually process all
-these connection requests. ``mpirun`` defaults to processing
-connection requests sequentially |mdash| so on large clusters, a
-backlog can be created that can cause remote daemons to timeout
-waiting for a response.
-
-Fortunately, Open MPI provides an alternative mechanism for processing
-connection requests that helps alleviate this problem. Setting the MCA
-parameter ``oob_tcp_listen_mode`` to ``listen_thread`` causes
-``mpirun`` to startup a separate thread dedicated to responding to
-connection requests. Thus, remote daemons receive a quick response to
-their connection request, allowing ``mpirun`` to deal with the message
-as soon as possible.
-
-.. error:: TODO This seems very out of date.  We should have content
-           about PMIx instant on.
-
-This parameter can be included in the default MCA parameter file,
-placed in the user's environment, or added to the ``mpirun`` command
-line.  See :ref:`this FAQ entry <label-running-setting-mca-param-values>`
-for more details on how to set MCA parameters.
+subsystem to pass control messages during the launch, initialization,
+and termination stages of a job. These messages allow ``mpirun`` to
+tell its daemons which processes to launch, and allow the daemons in
+turn to forward stdio to ``mpirun``, update ``mpirun`` on process
+status, and so on.
+
+.. note:: Since Open MPI 5.0, the run-time environment |mdash|
+   including the OOB subsystem and the ``mpirun`` launcher |mdash| is
+   provided by :ref:`PRRTE <label-running-role-of-pmix-and-prte>`, not
+   by Open MPI itself.
+
+The OOB uses TCP sockets, but the daemons do *not* all connect back to
+``mpirun``. Instead, PRRTE arranges them in a *radix tree*: each daemon
+connects only to its parent in that tree, and traffic bound for
+``mpirun`` is relayed up the tree hop by hop. The fan-out of the tree
+is set by the ``rml_base_radix`` PRTE MCA parameter, which defaults to
+64 |mdash| so no matter how large the job is, only the first 64 daemons
+connect directly to ``mpirun``, and each daemon below them accepts at
+most 64 connections from its own children.
+
+Similarly, when the ``ssh`` launcher is used, the daemons are also
+*launched* through a tree: each daemon ``ssh``\ s the next level of
+daemons into existence, rather than ``mpirun`` launching every daemon
+itself. (This can be disabled by setting the ``plm_ssh_no_tree_spawn``
+PRTE MCA parameter to 1, but there is rarely a reason to do so on a
+large cluster.)
+
+Together, these keep the connection and launch load on the node where
+``mpirun`` resides bounded rather than growing with the job size.
+``mpirun`` additionally services the connections it does receive on a
+dedicated listener thread, so remote daemons get a prompt response.
+This behavior is built in and requires no tuning.
+
+PMIx "Instant On"
+-----------------
+
+A larger contributor to startup cost at scale is the exchange of
+per-process communication endpoint information (the "modex") that MPI
+processes historically performed during ``MPI_Init`` in order to wire
+up their point-to-point connections. As the job size grows, this global
+exchange grows with it.
+
+Open MPI, PRRTE, and PMIx support the PMIx *Instant On* capability,
+which moves this work out of ``MPI_Init``. Rather than having the
+processes exchange endpoint information among themselves at run time,
+the launcher (PRRTE) and the fabric/network software collect the
+necessary network addressing information as part of the launch and
+pre-position it in each process's PMIx data store before the process
+starts. Each process can then look up any peer's endpoint information
+locally, so no global wireup exchange is required |mdash| the processes
+start already "wired up."
+
+Instant On is provided cooperatively by PMIx, PRRTE, and the
+network/fabric components. Whether |mdash| and how much of |mdash| it
+is available therefore depends on the interconnect and its software
+stack, rather than on a single user-settable MCA parameter. See the
+:ref:`PMIx and PRRTE section <label-running-role-of-pmix-and-prte>` for
+more information about these projects.
+
+For applications with sparse communication patterns, you can also
+reduce or eliminate the up-front modex with the
+``pmix_base_async_modex`` MCA parameter, which defers endpoint lookups
+until first message. See :doc:`reduce-startup-time` for details on that
+and other launch-time options.
diff --git a/docs/tuning-apps/large-clusters/static-cluster-config.rst b/docs/tuning-apps/large-clusters/static-cluster-config.rst
index b40cdc7bffe..d063dcbe3fb 100644
--- a/docs/tuning-apps/large-clusters/static-cluster-config.rst
+++ b/docs/tuning-apps/large-clusters/static-cluster-config.rst
@@ -1,43 +1,57 @@
 Static cluster configurations
 =============================
 
-.. error:: This entire section needs to be checked.
-
 Clusters rarely change from day-to-day, and large clusters rarely
 change at all.  If you know your cluster's configuration, there are
 several steps you can take to both reduce Open MPI's memory footprint
 and reduce the launch time of large-scale applications.  These steps
 use a combination of build-time configuration options to eliminate
-components |mdash| thus eliminating their libraries and avoiding
-unnecessary component open/close operations |mdash| as well as
-run-time MCA parameters to specify what modules to use by default for
-most users.
+components |mdash| making Open MPI's libraries smaller and avoiding the
+work of registering and querying components that will never be used
+|mdash| as well as run-time MCA parameters to select the components to
+use by default for most users.
+
+.. note:: Since Open MPI v5.0, components are, by default, compiled
+   directly into Open MPI's core libraries (for example,
+   ``libopen-pal`` and ``libmpi``) rather than being built as separate
+   dynamically-loaded plugins (DSOs).  Even when a component is compiled
+   in this way, it is still registered and queried at run time so that
+   each framework can decide which of its components to use.  The
+   techniques on this page |mdash| not building components you do not
+   need, and choosing framework defaults up front |mdash| therefore
+   still reduce both memory footprint and startup work.  See
+   :ref:`Components ("plugins"): static or DSO?
+   <label-install-packagers-dso-or-not>` for more about the static and
+   DSO build models and how to select between them.
 
-One way to save memory is to avoid building components that will
-actually never be selected by the system. Unless MCA parameters
-specify which components to open, built components are always opened
-and tested as to whether or not they should be selected for use. If
-you know that a component can build on your system, but due to your
-cluster's configuration will never actually be selected, then it is
-best to simply configure OMPI to not build that component by using the
-``--enable-mca-no-build`` configure option.
+One way to save memory is to avoid building components that will never
+be selected on your system.  Every component that is built into Open
+MPI is registered and tested at run time to decide whether it should be
+selected, unless MCA parameters restrict which components are
+considered.  If you know that a component can build on your system but,
+due to your cluster's configuration, will never actually be selected,
+then it is best to configure Open MPI to not build that component by
+using the ``--enable-mca-no-build`` configure option.
 
-For example, if you know that your system will only utilize the
-``ob1`` component of the PML framework, then you can ``no_build`` all
-the others. This not only reduces memory in the libraries, but also
-reduces memory footprint that is consumed by Open MPI opening all the
-built components to see which of them can be selected to run.
+For example, if you know that your system will only use the ``ob1``
+component of the PML framework, then you can ``no_build`` all the
+others.  This both makes the resulting libraries smaller and avoids the
+startup cost of registering and querying components that would never be
+used.
 
-In some cases, however, a user may optionally choose to use a
-component other than the default.  For example, you may want to build
-all of the PRRTE ``routed`` framework components, even though the vast
-majority of users will simply use the default ``debruijn``
+In some cases, however, you may want to keep a framework's other
+components built |mdash| so that users retain the option to select them
+|mdash| even though most users will use a single default.  For example,
+you may want to keep all of the ``pml`` framework's components built (so
+that users can still select ``ucx`` or ``cm`` when appropriate), even
+though the vast majority of users will use the default ``ob1``
 component.  This means you have to allow the system to build the other
 components, even though they may rarely be used.
 
 You can still save launch time and memory, though, by setting the
-``routed=debruijn`` MCA parameter in the default MCA parameter file.
-This causes OMPI to not open the other components during startup, but
-allows users to override this on their command line or in their
-environment so no functionality is lost |mdash| you just save some
+``pml = ob1`` MCA parameter in the default MCA parameter file.  This
+tells Open MPI to consider only the ``ob1`` component at startup, rather
+than registering and querying every ``pml`` component, but still allows
+users to override the setting on their command line or in their
+environment |mdash| so no functionality is lost, and you save some
 memory and time.
diff --git a/docs/tuning-apps/mpi-io.rst b/docs/tuning-apps/mpi-io.rst
index cf6327f9efd..ed01c961855 100644
--- a/docs/tuning-apps/mpi-io.rst
+++ b/docs/tuning-apps/mpi-io.rst
@@ -46,6 +46,13 @@ parameters available for the OMPIO ``io``, ``fcoll``, ``fs``,
    shell$ ompi_info --param fbtl     all --level 9
    shell$ ompi_info --param sharedfp all --level 9
 
+.. _label-ompio-mpi-info-hints:
+
+OMPIO MPI_Info hints
+--------------------
+
+.. include:: /tuning-apps/_include/ompio-mpi-info-hints.rst
+
 OMPIO sub-framework components
 ------------------------------
 
@@ -158,15 +165,15 @@ file on a parallel file system.  Note, that many file systems only
 allow changing these setting upon file creation, i.e. modifying these
 values for an already existing file might not be possible.
 
-#. ``fs_lustre_stripe_size``: Sets the number of storage servers for a
+#. ``fs_lustre_stripe_size``: Sets the stripe size, in bytes, for a
    new file on a Lustre file system. If not set, system default will
    be used. Note that this parameter can also be set through the
-   ``stripe_size`` MPI Info value.
+   ``striping_unit`` or ``stripe_size`` MPI Info value.
 
-#. ``fs_lustre_stripe_width``: Sets the size of an individual block
-   for a new file on a Lustre file system. If not set, system default
-   will be used. Note that this parameter can also be set through the
-   ``stripe_width`` MPI Info value.
+#. ``fs_lustre_stripe_width``: Sets the number of storage servers for
+   a new file on a Lustre file system. If not set, system default will
+   be used. Note that this parameter can also be set through the
+   ``striping_factor`` or ``stripe_width`` MPI Info value.
 
 Using GPU device buffers in MPI File I/O operations
 ----------------------------------------------------
@@ -207,7 +214,7 @@ individual files are merged into the actual output file, using the
 time stamps as the main criteria.
 
 The component has certain limitations and restrictions, such as its
-relience on the synchronization clocks on the individual cluster nodes
+reliance on the synchronization clocks on the individual cluster nodes
 to determine the order between entries in the final file, which might
 lead to some deviations compared to the actual calling sequence.
 
diff --git a/docs/tuning-apps/networking/ib-and-roce.rst b/docs/tuning-apps/networking/ib-and-roce.rst
index 7b722faf9a4..ff8c61d6506 100644
--- a/docs/tuning-apps/networking/ib-and-roce.rst
+++ b/docs/tuning-apps/networking/ib-and-roce.rst
@@ -1,188 +1,166 @@
-InifiniBand / RoCE support
-==========================
-
-.. error:: TODO This section needs to be converted from FAQ Q&A style
-           to regular documentation style.
-
-How are InfiniBand / RoCE devices supported in Open MPI?
---------------------------------------------------------
+InfiniBand / RoCE support
+=========================
 
 Open MPI's support for InfiniBand and RoCE devices has changed over
-time.
-
-In the Open MPI |ompi_series| series, InfiniBand and RoCE devices are
-supported via the UCX (``ucx``) PML.
+time.  In the Open MPI |ompi_series| series, InfiniBand and RoCE
+devices are supported via the UCX (``ucx``) PML.
 
 .. note:: Prior versions of Open MPI also included the ``openib`` BTL
           for InfiniBand and RoCE devices.  Open MPI |ompi_series| no
           longer includes the ``openib`` BTL.
 
-/////////////////////////////////////////////////////////////////////////
-
-What is UCX?
-------------
-
-`UCX <https://openucx.org/>`_ is an open-source optimized
-communication library which supports multiple networks, including
-RoCE, InfiniBand, uGNI, TCP, shared memory, and others. UCX
-mixes-and-matches transports and protocols which are available on the
-system to provide optimal performance. It also has built-in support
-for GPU transports (with CUDA and ROCm providers) which lets
-RDMA-capable transports access the GPU memory directly.
+UCX
+---
 
-/////////////////////////////////////////////////////////////////////////
+`UCX <https://openucx.org/>`_ is an open-source, optimized
+communication library that supports multiple networks, including RoCE,
+InfiniBand, uGNI, TCP, shared memory, and others.  UCX
+mixes-and-matches the transports and protocols available on the system
+to provide optimal performance.  It also has built-in support for GPU
+transports (with CUDA and ROCm providers), which lets RDMA-capable
+transports access GPU memory directly.
 
-How do I use UCX with Open MPI?
--------------------------------
+Using UCX with Open MPI
+-----------------------
 
 If Open MPI includes UCX support, then UCX is enabled and selected by
 default for InfiniBand and RoCE network devices; typically, no
 additional parameters are required.  In this case, the network port
-with the highest bandwidth on the system will be used for inter-node
-communication, and shared memory will be used for intra-node
-communication.  To select a specific network device to use (for
-example, ``mlx5_0`` device port 1):
+with the highest bandwidth on the system is used for inter-node
+communication, and shared memory is used for intra-node communication.
+
+To select a specific network device to use (for example, the
+``mlx5_0`` device, port 1):
 
 .. code-block::
 
    shell$ mpirun -x UCX_NET_DEVICES=mlx5_0:1 ...
 
-It's also possible to force using UCX for MPI point-to-point and
+It is also possible to force the use of UCX for MPI point-to-point and
 one-sided operations:
 
 .. code-block::
 
    shell$ mpirun --mca pml ucx --mca osc ucx ...
 
-For OpenSHMEM, in addition to the above, it's possible to force using
-UCX for remote memory access and atomic memory operations:
+For OpenSHMEM, in addition to the above, you can force the use of UCX
+for remote memory access and atomic memory operations:
 
 .. code-block::
 
    shell$ mpirun --mca pml ucx --mca osc ucx --mca scoll ucx --mca atomic ucx ...
 
-/////////////////////////////////////////////////////////////////////////
-
-What is RDMA over Converged Ethernet (RoCE)?
---------------------------------------------
+RDMA over Converged Ethernet (RoCE)
+-----------------------------------
 
-RoCE (which stands for *RDMA over Converged Ethernet*) provides
-InfiniBand native RDMA transport on top of lossless Ethernet data
-links.
-
-Since we're talking about Ethernet, there's no Subnet Manager, no
-Subnet Administrator, no InfiniBand SL, nor any other InfiniBand
-Subnet Administration parameters.
+RoCE (RDMA over Converged Ethernet) provides the InfiniBand native RDMA
+transport on top of lossless Ethernet data links.  Because the
+underlying link is Ethernet, there is no Subnet Manager, no Subnet
+Administrator, no InfiniBand Service Level, and none of the other
+InfiniBand Subnet Administration parameters.
 
 Connection management in RoCE is based on the OFED RDMACM (RDMA
 Connection Manager) service:
 
-* The OS IP stack is used to resolve remote (IP,hostname) tuples to
-  a DMAC.
-* The outgoing Ethernet interface and VLAN are determined according
-  to this resolution.
+* The OS IP stack is used to resolve remote (IP, hostname) tuples to a
+  DMAC.
+* The outgoing Ethernet interface and VLAN are determined according to
+  this resolution.
 * The appropriate RoCE device is selected accordingly.
-* Network parameters (such as MTU, SL, timeout) are set locally by
+* Network parameters (such as MTU, SL, and timeout) are set locally by
   the RDMACM in accordance with kernel policy.
 
-/////////////////////////////////////////////////////////////////////////
+Running over RoCE
+-----------------
 
-How do I know what MCA parameters are available for tuning MPI performance?
----------------------------------------------------------------------------
-
-The ``ompi_info`` command can display all the parameters available for
-any Open MPI component.  For example:
+To use RoCE with the UCX PML, specify the relevant Ethernet port with
+the ``UCX_NET_DEVICES`` environment variable.  For example:
 
 .. code-block::
 
-   shell$ ompi_info --param pml ucx --level 9
-
-.. important:: Unlike most other Open MPI components, the UCX PML
-               mainly uses environment variables for run-time tuning
-               |mdash| not Open MPI MCA parameters.  Consult `the UCX
-               documentation
-               <https://openucx.org/documentation/>`_ for details
-               about what environment variables are available.
-
-/////////////////////////////////////////////////////////////////////////
-
-How do I tell Open MPI which IB Service Level to use?
------------------------------------------------------
+   shell$ mpirun --mca pml ucx -x UCX_NET_DEVICES=mlx5_0:1 ...
 
-In order to tell the UCX PML which SL to use, the IB SL must be
-specified using the ``UCX_IB_SL`` environment variable.  For example:
+UCX selects IPv4 RoCEv2 by default.  If different behavior is needed,
+you can set a specific GID index:
 
 .. code-block::
 
-   shell$ mpirun --mca pml ucx -x UCX_IB_SL=N ...
+   shell$ mpirun --mca pml ucx -x UCX_NET_DEVICES=mlx5_0:1 -x UCX_IB_GID_INDEX=1 ...
 
-The value of IB SL ``N`` should be between 0 and 15, where 0 is the
-default value.
+Selecting the InfiniBand Service Level
+--------------------------------------
 
-/////////////////////////////////////////////////////////////////////////
+To tell the UCX PML which InfiniBand Service Level (SL) to use, specify
+it with the ``UCX_IB_SL`` environment variable.  For example:
 
-How do I run Open MPI over RoCE?
---------------------------------
+.. code-block::
 
-In order to use RoCE with the UCX PML, the relevant Ethernet port must
-be specified using the ``UCX_NET_DEVICES`` environment variable.  For
-example:
+   shell$ mpirun --mca pml ucx -x UCX_IB_SL=N ...
 
-.. code-block::
+The value ``N`` should be between 0 and 15, where 0 is the default.
 
-   shell$ mpirun --mca pml ucx -x UCX_NET_DEVICES=mlx5_0:1 ...
+Tuning MPI performance
+----------------------
 
-UCX selects IPv4 RoCEv2 by default. If different behavior is needed,
-you can set a specific GID index:
+The ``ompi_info`` command can display all the parameters available for
+any Open MPI component.  For example:
 
 .. code-block::
 
-   shell$ mpirun --mca pml ucx -x UCX_NET_DEVICES=mlx5_0:1 -x UCX_IB_GID_INDEX=1 ...
+   shell$ ompi_info --param pml ucx --level 9
 
-/////////////////////////////////////////////////////////////////////////
+.. important:: Unlike most other Open MPI components, the UCX PML mainly
+               uses environment variables for run-time tuning |mdash|
+               not Open MPI MCA parameters.  Consult `the UCX
+               documentation <https://openucx.org/documentation/>`_ for
+               details about which environment variables are available.
 
 .. _faq-ib-troubleshoot-label:
 
-I'm experiencing a problem with Open MPI on my InfiniBand / RoCE network; how do I troubleshoot and get help?
--------------------------------------------------------------------------------------------------------------
+Troubleshooting and getting help
+--------------------------------
 
-In order for us to help you, it is *most* helpful if you can run a few
-steps before sending an e-mail to both perform some basic
-troubleshooting and provide us with enough information about your
-environment to help you.  Please include answers to the following
-questions in your e-mail:
+If you are experiencing a problem with Open MPI on an InfiniBand or
+RoCE network, it is *most* helpful if you run a few steps before
+sending an e-mail, both to perform some basic troubleshooting and to
+provide enough information about your environment for others to help
+you.  Please include answers to the following questions in your e-mail:
 
-#. Which UCX and OpenFabrics version are you running?  Please specify
-   where you got the software from (e.g., from the OpenFabrics and/or
-   UCX community web sites, already included in your Linux
+#. Which UCX and OpenFabrics versions are you running?  Please specify
+   where you obtained the software (for example, from the OpenFabrics
+   and/or UCX community web sites, already included in your Linux
    distribution, downloaded from NVIDIA's web site, etc.).
 
-#. What distro and version of Linux are you running?  What is your
-   kernel version?
+#. Which distribution and version of Linux are you running?  What is
+   your kernel version?
 
 #. What is the output of the ``ibv_devinfo`` command on a known "good"
    node and a known "bad" node?
 
-   .. note:: There must be at least one port listed as "PORT_ACTIVE"
+   .. note:: There must be at least one port listed as ``PORT_ACTIVE``
              for Open MPI to work.  If there is not at least one
-             PORT_ACTIVE port, something is wrong with your InfiniBand
-             / RoCE environment and Open MPI will not be able to run.
+             ``PORT_ACTIVE`` port, something is wrong with your
+             InfiniBand / RoCE environment, and Open MPI will not be
+             able to run.
 
 #. What is the output of the ``ifconfig`` command on a known "good"
    node and a known "bad" node?
 
-   .. note:: Note that some Linux distributions do not put
-             ``ifconfig`` in the default path for normal users; look
-             for it at ``/sbin/ifconfig`` or ``/usr/sbin/ifconfig``.
+   .. note:: Some Linux distributions do not put ``ifconfig`` in the
+             default path for normal users; look for it at
+             ``/sbin/ifconfig`` or ``/usr/sbin/ifconfig``.
 
 #. If running under Bourne shells, what is the output of the ``ulimit
-   -l`` command?
-
-   If running under C shells, what is the output of the ``limit | grep
-   memorylocked`` command?
-
-   .. note:: If the value is not ``unlimited``, .................
-
-   .. error:: TODO Would be good to point to some UCX/vendor docs here
-              about setting memory limits (rather than reproducing this
-              information ourselves).
+   -l`` command?  If running under C shells, what is the output of the
+   ``limit | grep memorylocked`` command?
+
+   This reports the maximum amount of memory that a user process is
+   allowed to lock (pin) into physical RAM.  InfiniBand and RoCE
+   transfers use RDMA, which requires the communication buffers to be
+   locked so that the network hardware can access them directly.  If
+   the reported value is not ``unlimited`` (or is not large enough for
+   your application's buffers), memory registration can fail and MPI
+   jobs may abort or perform poorly.  Raising this limit is a
+   system-configuration task; see the `UCX documentation
+   <https://openucx.org/documentation/>`__ and your OpenFabrics or
+   vendor documentation for how to allow locked memory on your system.
diff --git a/docs/tuning-apps/networking/iwarp.rst b/docs/tuning-apps/networking/iwarp.rst
index a24b3c73fbb..79293fa58e9 100644
--- a/docs/tuning-apps/networking/iwarp.rst
+++ b/docs/tuning-apps/networking/iwarp.rst
@@ -6,7 +6,7 @@ Open MPI's support for iWARP devices has changed over time.
 In the Open MPI |ompi_series| series, iWARP devices are
 supported via the OFI (``ofi``) MTL via the CM (``cm``) PML.
 
-.. note:: Prior versions of Open MPI supported iWARP devies via the
+.. note:: Prior versions of Open MPI supported iWARP devices via the
           ``openib`` BTL.  Open MPI |ompi_series| no longer includes
           the ``openib`` BTL.
 
diff --git a/docs/tuning-apps/networking/ofi.rst b/docs/tuning-apps/networking/ofi.rst
index 3f7563985d1..e3819fa6cc3 100644
--- a/docs/tuning-apps/networking/ofi.rst
+++ b/docs/tuning-apps/networking/ofi.rst
@@ -1,15 +1,9 @@
 OpenFabrics Interfaces (OFI) / Libfabric support
 ================================================
 
-.. error:: TODO This section needs to be converted from FAQ Q&A style
-           to regular documentation style.
-
-What is OFI / Libfabric?
-------------------------
-
 "OFI" stands for the `OpenFabrics Interfaces
 <https://libfabric.org/>`_, which are implemented in the ``libfabric``
-library.  These two terms are typically used interchangeably.
+library; the two terms are typically used interchangeably.
 
 Open MPI supports many different underlying networks via Libfabric,
 including (but not limited to):
@@ -19,117 +13,111 @@ including (but not limited to):
 * Cornelis Networks Omni-Path
 * HPE Slingshot 11
 
-In general, the OFI-based components in Open MPI will auto-select
-themselves as appropriate at run time.
-
-That being said, additional questions are available in this FAQ
-section to provide more information about specific OFI-based network
-types and support.
-
-/////////////////////////////////////////////////////////////////////////
-
-What are the Libfabric (OFI) components in Open MPI?
-----------------------------------------------------
-
-Open MPI has three main components for Libfabric (a.k.a., OFI)
-communications:
-
-#. ``ofi`` MTL: Available since Open MPI v1.10, this component is used
-   with the ``cm`` PML and is used for two-sided MPI communication
-   (e.g., ``MPI_SEND`` and ``MPI_RECV``).
-
-  The ``ofi`` MTL requires that the Libfabric provider support
-  reliable datagrams with ordered tagged messaging (specifically:
-  ``FI_EP_RDM`` endpoints, ``FI_TAGGED`` capabilities, and
-  ``FI_ORDER_SAS`` ordering).
-
-#. ``ofi`` BTL: Available since Open MPI v4.0.0, this component is primarily
-   intended for one-sided MPI communications (e.g., ``MPI_PUT``). It
-   can also support BTL send/recv operations.
-   ``ofi`` BTL requires that the Libfabric provider support reliable
-   datagrams, RMA and atomic operations, and remote atomic completion
-   notifications (specifically: ``FI_EP_RDM`` endpoints, ``FI_RMA``
-   and ``FI_ATOMIC`` capabilities, and ``FI_DELIVERY_COMPLETE`` op
-   flags).
-
-#. ``usnic`` BTL: This BTL is used exclusively with Cisco usNIC-based
-   networks.  It will auto-select itself over the other OFI-based
-   components when run with Cisco usNIC-based networks.
-
-See each Lifabric provider man page (e.g., fi_sockets(7)) to understand which
-provider will work for each of the above-listed Open MPI components. Some
-providers may require to be used with one of the Libfabric utility providers;
-for example, the verbs provider needs to be paired with utility provider
-``ofi_rxm`` to provide reliable datagram endpoint support (``verbs;ofi_rxm``).
-
-Both components have MCA parameters to specify the Libfabric provider(s) that
-will be included/excluded in the selection process. For example:
+In general, the OFI-based components in Open MPI auto-select themselves
+as appropriate at run time.  The remaining sections describe the
+OFI-based components and the tuning options for specific OFI-based
+network types.
+
+Libfabric (OFI) components in Open MPI
+--------------------------------------
+
+Open MPI has three main components for Libfabric (OFI) communication:
+
+#. The ``ofi`` MTL, available since Open MPI v1.10, is used with the
+   ``cm`` PML for two-sided MPI communication (for example,
+   ``MPI_Send`` and ``MPI_Recv``).  It requires that the Libfabric
+   provider support reliable datagrams with ordered tagged messaging
+   |mdash| specifically, ``FI_EP_RDM`` endpoints, ``FI_TAGGED``
+   capabilities, and ``FI_ORDER_SAS`` ordering.
+
+#. The ``ofi`` BTL, available since Open MPI v4.0.0, is primarily
+   intended for one-sided MPI communication (for example,
+   ``MPI_Put``), but can also support BTL send/receive operations.  It
+   requires that the Libfabric provider support reliable datagrams, RMA
+   and atomic operations, and remote atomic completion notifications
+   |mdash| specifically, ``FI_EP_RDM`` endpoints, ``FI_RMA`` and
+   ``FI_ATOMIC`` capabilities, and the ``FI_DELIVERY_COMPLETE`` op
+   flag.
+
+#. The ``usnic`` BTL is used exclusively with Cisco usNIC-based
+   networks.  It auto-selects itself over the other OFI-based
+   components when run on such networks.
+
+Consult each Libfabric provider's man page (for example,
+``fi_sockets(7)``) to understand which provider will work for each of
+the components above.  Some providers must be paired with a Libfabric
+utility provider; for example, the verbs provider needs the ``ofi_rxm``
+utility provider to supply reliable datagram endpoint support
+(``verbs;ofi_rxm``).
+
+Each component has MCA parameters that specify the Libfabric
+provider(s) to include in or exclude from the selection process.  For
+example:
 
 .. code-block::
 
-   shell$ mpirun --mca pml cm --mca mtl ofi --mca mtl_ofi_provider_include psm2 mpi_hello
+   shell$ mpirun --mca pml cm --mca mtl ofi \
+          --mca mtl_ofi_provider_include psm2 ./mpi_hello
 
-In addition, each component has specific parameters for each one; see
-``ompi_info --param <framework> <component> -level 9`` for a full
-list. For example:
+Each component also has its own component-specific parameters; use
+``ompi_info`` to list them.  For example:
 
 .. code-block::
 
    shell$ ompi_info --param mtl ofi --level 9
 
-.. important:: When using the HPE CXI provider and ``mpirun`` as the job launcher,
-          it is recommended that the PRTE ``ras_base_launch_orted_on_hn`` MCA parameter be set to 1.
-          This can be done by adding ``--prtemca ras_base_launch_orted_on_hn 1`` to the job launch
-          command line.  This ensures that MPI processes launched on the first node of
-          an allocation are able to use the CXI provider.
-          
-For more information refer to the `Libfabric web site
-<https://libfabric.org/>`_.
+.. important:: When using the HPE CXI provider with ``mpirun`` as the
+               job launcher, it is recommended to set the PRRTE
+               ``ras_base_launch_orted_on_hn`` MCA parameter to 1 by
+               adding ``--prtemca ras_base_launch_orted_on_hn 1`` to
+               the job launch command line.  This ensures that MPI
+               processes launched on the first node of an allocation
+               are able to use the CXI provider.
 
-/////////////////////////////////////////////////////////////////////////
+For more information, refer to the `Libfabric web site
+<https://libfabric.org/>`_.
 
-Omni-Path: How can the multi-rail settings be adjusted if multiple HFI (Host Fabric Interface) cards are installed on the system?
----------------------------------------------------------------------------------------------------------------------------------
+Omni-Path: multi-rail with multiple HFI cards
+---------------------------------------------
 
-Multi-Rail feature allows a process to use multiple HFIs to transfer a message
-to improve message bandwidth. The PSM2 library handles the support for multi-rail
-which is off by default. The multi-rail settings can be modified using the
-following environment variables:
+The multi-rail feature lets a single process use multiple Host Fabric
+Interface (HFI) cards to transfer a message, improving message
+bandwidth.  The PSM2 library provides multi-rail support, which is off
+by default.  The behavior is controlled with the following environment
+variables:
 
-* ``PSM2_MULTIRAIL=[0,1,2] ]``: 0=Disabled, 1=Enable across all HFIs in the
-  system, 2=Enable multi-rail within a NUMA node.
-* ``PSM2_MULTIRAIL_MAP=unit:port,unit:port...``
+* ``PSM2_MULTIRAIL=[0,1,2]``: 0 disables multi-rail, 1 enables it
+  across all HFIs in the system, and 2 enables multi-rail within a NUMA
+  node.
+* ``PSM2_MULTIRAIL_MAP=unit:port,unit:port,...``
 
-The variables above may be included in the ``mpirun`` command line or in
-the environment. For example:
+These variables may be set on the ``mpirun`` command line or in the
+environment.  For example:
 
 .. code-block::
 
-   shell$ mpirun -mca mtl [psm2|ofi] -x PSM2_MULTIRAIL=1 -n 2 -H host1,host2 ./a.out
-
-.. note:: When using the OFI MTL, please ensure that the PSM2 OFI
-          provider is used for communication with OPA devices.
-
-/////////////////////////////////////////////////////////////////////////
+   shell$ mpirun --mca mtl [psm2|ofi] -x PSM2_MULTIRAIL=1 \
+          -n 2 -H host1,host2 ./a.out
 
-Omni-Path: What is Multi-HFI support in PSM2 and how does it differ from multi-rail?
-------------------------------------------------------------------------------------
+.. note:: When using the OFI MTL, ensure that the PSM2 OFI provider is
+          used for communication with OPA devices.
 
-Multi-HFI support is intended to describe the use of multiple HFIs in
-a system among MPI ranks local to a node in order to load-balance the
-hardware resources. It differs from the Multi-Rail feature, which is
-intended to allow a single process to use all HFIs in the system. For
-an MPI job with multiple processes on a single node, the default PSM2
-behavior depends on the affinity settings of the MPI process. The PSM2
-library defaults to using the HFI (Host Fabric Interface) that is in
-the same NUMA node as that of the MPI process.
+Omni-Path: multi-HFI support in PSM2
+------------------------------------
 
-Users can restrict access to a single HFI using the environment variable:
+Multi-HFI support describes the use of multiple HFIs in a system among
+the MPI ranks local to a node, in order to load-balance the hardware
+resources.  It differs from the multi-rail feature, which allows a
+single process to use all HFIs in the system.  For an MPI job with
+multiple processes on a single node, the default PSM2 behavior depends
+on the affinity settings of the MPI process: the PSM2 library defaults
+to using the HFI that is in the same NUMA node as the MPI process.
 
-* ``HFI_UNIT=N``: valid values of N are 0,1,2 and 3
+Users can restrict a process to a single HFI with an environment
+variable:
 
-More details can be found on the PSM2 Programmer's Guide and the Omni-Path
-Fabric Performance Tuning Guide.
+* ``HFI_UNIT=N``: valid values of ``N`` are 0, 1, 2, and 3.
 
-Please see the `Cornelis Networks Customer Center <https://customercenter.cornelisnetworks.com/>`_
-for more details.
+More details can be found in the PSM2 Programmer's Guide and the
+Omni-Path Fabric Performance Tuning Guide; see the `Cornelis Networks
+Customer Center <https://customercenter.cornelisnetworks.com/>`_.
diff --git a/docs/tuning-apps/networking/tcp.rst b/docs/tuning-apps/networking/tcp.rst
index 7b87546596c..60ddb65e214 100644
--- a/docs/tuning-apps/networking/tcp.rst
+++ b/docs/tuning-apps/networking/tcp.rst
@@ -1,126 +1,99 @@
 TCP
 ===
 
-.. error:: TODO This section needs to be converted from FAQ Q&A style
-           to regular documentation style.
+Using the TCP BTL for MPI messages
+----------------------------------
 
-How do I specify to use the IP network for MPI messages?
---------------------------------------------------------
+Open MPI generally uses the ``tcp`` BTL automatically when:
 
-Open MPI will generally automatically use the ``tcp`` BTL when:
+#. The ``tcp`` BTL is available at run time (which it should be on most
+   POSIX-like systems), and
+#. A higher-performance network is not available.
 
-#. The ``tcp`` BTL is  available at run time (which it should be on
-   most POSIX-like systems), and
-#. A higher-performance network is not available
+When the ``tcp`` BTL is used, it is typically also used (automatically)
+with the ``self`` and ``sm`` BTLs for process-loopback and node-loopback
+communication, respectively.
 
-When the ``tcp`` BTL is used, it is typically also (automatically)
-used with the ``self`` and ``sm`` BTLs for process-loopback and
-node-loopback communication, respectively.
-
-If you want to guarantee that the ``tcp``, ``sm``, and ``self`` BTLs
-are used, you can explicitly specify them on the ``mpirun`` command
-line:
+To guarantee that the ``tcp``, ``sm``, and ``self`` BTLs are used, you
+can specify them explicitly on the ``mpirun`` command line:
 
 .. code-block:: sh
 
    shell$ mpirun --mca pml ob1 --mca btl tcp,sm,self ...
 
 .. warning:: Failure to specify the ``sm`` BTL will likely result in
-             lower performance when Open MPI uses the TCP network
-             stack to send to peers on the same host.
-
-.. warning:: Failure to specify the ``self`` BTL may result in Open
-             MPI being unable to complete send-to-self scenarios
-             (meaning that your program will run fine until a process
-             tries to send to itself).
-
-/////////////////////////////////////////////////////////////////////////
-
-But wait |mdash| I'm using a high-speed network.  Do I have to disable the TCP BTL?
------------------------------------------------------------------------------------
-
-No.  Following the so-called "Law of Least Astonishment", Open MPI
-assumes that if you have both an IP network and at least one
-high-speed network (such InfiniBand), you will likely only want to use
-the high-speed network(s) for MPI message passing.  Hence, the ``tcp``
-BTL component will sense this and automatically deactivate itself.
-
-That being said, Open MPI may still use TCP for setup and teardown
-information |mdash| so you'll see traffic across your IP network during
+             lower performance when Open MPI uses the TCP network stack
+             to send to peers on the same host.
+
+.. warning:: Failure to specify the ``self`` BTL may result in Open MPI
+             being unable to complete send-to-self scenarios (meaning
+             that your program will run fine until a process tries to
+             send to itself).
+
+Coexisting with a high-speed network
+------------------------------------
+
+If you have both an IP network and at least one high-speed network
+(such as InfiniBand), you do not need to disable the TCP BTL.
+Following the so-called "Law of Least Astonishment," Open MPI assumes
+that you will likely want to use only the high-speed network(s) for MPI
+message passing, so the ``tcp`` BTL component senses this and
+automatically deactivates itself.
+
+That said, Open MPI may still use TCP for setup and teardown
+information, so you will see traffic across your IP network during
 startup and shutdown of your MPI job.  This is normal and does not
-affect the MPI message passing channels.
-
-/////////////////////////////////////////////////////////////////////////
+affect the MPI message-passing channels.
 
-How do I know what MCA parameters are available for tuning MPI performance?
----------------------------------------------------------------------------
+Listing tunable parameters
+--------------------------
 
-The ``ompi_info`` command can display all the parameters
-available for the ``tcp`` BTL component (i.e., the component that uses
-TCP for MPI communications):
+The ``ompi_info`` command can display all the parameters available for
+the ``tcp`` BTL component (that is, the component that uses TCP for MPI
+communication):
 
 .. code-block:: sh
 
    shell$ ompi_info --param btl tcp --level 9
 
-/////////////////////////////////////////////////////////////////////////
-
-Does Open MPI use the IP loopback interface?
---------------------------------------------
-
-Usually not.
+The IP loopback interface
+-------------------------
 
-In general message passing usage, there are two scenarios where using
-the operating system IP loopback interface could be used:
+Open MPI usually does *not* use the operating system IP loopback
+interface.  In general message-passing usage, there are two scenarios
+in which the IP loopback interface could be used:
 
-#. Sending a message from one process to itself
+#. Sending a message from one process to itself, and
 #. Sending a message from one process to another process on the same
-   machine
-
-The TCP BTL does not handle "send-to-self" scenarios in Open MPI.
-Instead, the ``self`` BTL is used for all send-to-self MPI communications.
-This allows all Open MPI BTL components to avoid special case code
-for send-to-self scenarios, and also avoids using less efficient
-loopback network stacks (such as the IP loopback device). However,
-in cases where there is a need to use the IP loopback device, the ``tcp``
-BTL can be configured to use it by setting the ``btl_tcp_if_include``
-MCA parameter to ``lo`` or ``127.0.0.0/32`` (or whatever is the local
-naming scheme on your system). For example:
+   machine.
+
+The ``tcp`` BTL does not handle send-to-self scenarios; instead, the
+``self`` BTL is used for all send-to-self MPI communication.  This lets
+all Open MPI BTL components avoid special-case code for send-to-self
+and also avoids using less efficient loopback network stacks (such as
+the IP loopback device).  The ``self`` component uses its own
+mechanisms and does not use operating system network interfaces such as
+the IP loopback interface.
+
+When sending to other processes on the same machine, Open MPI defaults
+to using a shared-memory BTL (``sm``).  If the shared-memory BTL has
+been deactivated, then |mdash| depending on what other BTL components
+are available |mdash| it is possible that the ``tcp`` BTL will be
+chosen for on-node message passing, in which case the IP loopback
+device will likely be used.  This is not the default, however: either
+shared memory must fail to start up properly, or the user must
+specifically request not to use the shared-memory BTL.  If you do need
+to use the IP loopback device, the ``tcp`` BTL can be configured to use
+it by setting the ``btl_tcp_if_include`` MCA parameter to ``lo`` or
+``127.0.0.0/32`` (or whatever the local naming scheme is on your
+system).  For example:
 
 .. code-block:: sh
 
    shell$ mpirun --mca btl_tcp_if_include lo ...
-   shell$ mpirun --mca btl_tcp_if_exclude 127.0.0.0/32 ...
-
-
-Specifically: the ``self`` component uses its own mechanisms for
-send-to-self scenarios; it does not use operating system network
-interfaces such as the IP loopback interface.
-
-When sending to other processes on the same machine, Open MPI will
-default to using a shared memory BTL (``sm``).  If the user has
-deactivated these BTLs, depending on what other BTL components are
-available, it is possible that the TCP BTL will be chosen for message
-passing to processes on the same node, in which case the IP loopback
-device will likely be used.  But this is not the default; either
-shared memory has to fail to startup properly or the user must
-specifically request not to use the shared memory BTL.
-
-/////////////////////////////////////////////////////////////////////////
-
-I have multiple IP networks on some/all of my cluster nodes.  Which ones will Open MPI use?
--------------------------------------------------------------------------------------------
-
-In general, Open MPI will greedily use all IP networks that
-it finds per its :ref:`reachability computations <faq-tcp-routability>`.
-
-To change this behavior, you can either specifically include certain
-networks or specifically exclude certain networks.  :ref:`See this FAQ
-entry <faq-tcp-selection>` for more details.
-
-/////////////////////////////////////////////////////////////////////////
 
-I'm getting TCP-related errors.  What do they mean?
+Interpreting TCP-related errors
+-------------------------------
 
 TCP-related errors are usually reported by Open MPI in a message
 similar to these:
@@ -130,8 +103,8 @@ similar to these:
    btl_tcp_endpoint.c:572:mca_btl_tcp_endpoint_complete_connect: connect() failed with errno=113
    mca_btl_tcp_frag_send: writev failed with errno=104
 
-If an `errno` number is displayed with no explanation string, you can
-see what that specific error number means on your operating system.
+If an ``errno`` number is displayed with no explanation string, you can
+look up what that specific error number means on your operating system.
 On Linux, you can use the ``perror`` command:
 
 .. code-block:: sh
@@ -144,178 +117,169 @@ On Linux, you can use the ``perror`` command:
    shell$ perror 104
    OS error code 104:  Connection reset by peer
 
-Two types of errors are commonly reported to the Open MPI user's
+Two types of errors are commonly reported to the Open MPI users'
 mailing list:
 
-#. **No route to host:** These types of errors *usually* mean that
-   there are multiple IP interfaces available and they do not obey
-   Open MPI's assumptions about routability.  See :ref:`the TCP
-   routability assumptions FAQ entry <faq-tcp-routability>` and
-   :ref:`the TCP selection FAQ entry <faq-tcp-selection>` for more
-   information.
+#. **No route to host:** These errors *usually* mean that there are
+   multiple IP interfaces available and they do not obey Open MPI's
+   assumptions about routability.  See :ref:`how Open MPI determines
+   routability <faq-tcp-routability>` and :ref:`selecting which IP
+   interfaces to use <faq-tcp-selection>` for more information.
 
-#. **Connection reset by peer:** These types of errors *usually* occur
-   after ``MPI_INIT`` has completed, and typically indicate that an
-   MPI process has died unexpectedly (e.g., due to a catastrophic error
-   such as a segmentation fault).  The specific error message
-   indicates that a peer MPI process tried to write to the now-dead
-   MPI process and failed.
-
-/////////////////////////////////////////////////////////////////////////
+#. **Connection reset by peer:** These errors *usually* occur after
+   ``MPI_Init`` has completed, and typically indicate that an MPI
+   process has died unexpectedly (for example, due to a catastrophic
+   error such as a segmentation fault).  The message indicates that a
+   peer MPI process tried to write to the now-dead MPI process and
+   failed.
 
 .. _faq-tcp-selection:
 
-How do I tell Open MPI which IP interfaces / networks to use?
--------------------------------------------------------------
+Selecting which IP interfaces to use
+------------------------------------
 
 In some HPC environments, it is not uncommon to have multiple IP
-interfaces on each node |mdash| for example, one IP network may be
-"slow" and used for control information such as a batch scheduler, a
-networked filesystem, and/or interactive logins.  Another IP network
-(or networks) may be "fast" and be intended for parallel applications
-to use during their runs.  As another example, some operating systems
-may also have virtual interfaces for communicating with virtual
-machines.
-
-Unless otherwise specified, Open MPI will greedily use all "up" IP
-networks that it can find and try to connect to all peers *upon
-demand* (i.e., Open MPI does not open sockets to all of its MPI peers
-during ``MPI_INIT`` |mdash| see :ref:`this FAQ entry
-<faq-tcp-sockets>` for more details).  Hence, if you want MPI jobs to
-not use specific IP networks |mdash| or not use any IP networks at all
-|mdash| then you need to tell Open MPI.
+interfaces on each node |mdash| for example, one "slow" IP network used
+for control information (such as a batch scheduler, a networked
+filesystem, and/or interactive logins) and another "fast" IP network
+(or networks) intended for parallel applications to use during their
+runs.  Some operating systems may also have virtual interfaces for
+communicating with virtual machines.
+
+Unless otherwise specified, Open MPI greedily uses all "up" IP networks
+that it can find, per its :ref:`reachability computations
+<faq-tcp-routability>`, and tries to connect to all peers *on demand*
+(Open MPI does not open sockets to all of its MPI peers during
+``MPI_Init`` |mdash| see :ref:`sockets opened during MPI_Init
+<faq-tcp-sockets>`).  If you want MPI jobs to not use specific IP
+networks |mdash| or not use any IP networks at all |mdash| then you
+must tell Open MPI.
 
 .. warning:: Aggressively using all "up" interfaces can cause problems
              in some cases.  For example, if you have a machine with a
-             local-only interface (e.g., the loopback device, or a
+             local-only interface (such as the loopback device, or a
              virtual-machine bridge device that can only be used *on
-             that machine*, and cannot be used to communicate with MPI
-             processes on other machines), you will likely need to
-             tell Open MPI to ignore these networks.
+             that machine* and cannot be used to communicate with MPI
+             processes on other machines), you will likely need to tell
+             Open MPI to ignore these networks.
 
              Open MPI usually ignores loopback devices by default, but
-             *other local-only devices must be manually ignored.*
-             Users have reported cases where RHEL6 automatically
-             installed a ``virbr0`` device for Xen virtualization.
-             This interface was automatically given an IP address in
-             the 192.168.1.0/24 subnet and marked as "up".  Since Open
-             MPI saw this 192.168.1.0/24 "up" interface in all MPI
-             processes on all nodes, it assumed that that network was
-             usable for MPI communications.  This is obviously
-             incorrect, and it led to MPI applications hanging when
-             they tried to send or receive MPI messages.
-
-#. To disable Open MPI from using TCP for MPI communications, the
-   ``tcp`` MCA parameter should be set accordingly.  You can either
-   *exclude* the TCP component or *include* all other components.
-   Specifically:
+             *other local-only devices must be manually ignored.* Users
+             have reported cases where RHEL6 automatically installed a
+             ``virbr0`` device for Xen virtualization.  This interface
+             was automatically given an IP address in the 192.168.1.0/24
+             subnet and marked as "up".  Since Open MPI saw this
+             192.168.1.0/24 "up" interface in all MPI processes on all
+             nodes, it assumed that network was usable for MPI
+             communication.  This is obviously incorrect, and it led to
+             MPI applications hanging when they tried to send or receive
+             MPI messages.
+
+There are several ways to control which interfaces Open MPI uses:
+
+#. To prevent Open MPI from using TCP for MPI communication at all, set
+   the ``btl`` MCA parameter accordingly.  You can either *exclude* the
+   TCP component or *include* only other components:
 
    .. code-block:: sh
 
-      # This says to exclude the TCP BTL component
-      # (implicitly including all others)
-      shell$ mpirun --mca btl ^tcp...
+      # Exclude the TCP BTL component (implicitly including all others)
+      shell$ mpirun --mca btl ^tcp ...
 
-      # This says to include only the listed BTL components
+      # Include only the listed BTL components
       # (tcp is not listed, and therefore will not be used)
-      shell$ mpirun --mca btl self,vader,openib ...
+      shell$ mpirun --mca btl self,sm ...
 
-#. If you want to use TCP for MPI communications, but want to restrict
-   it from certain networks, use the ``btl_tcp_if_include`` or
-   ``btl_tcp_if_exclude`` MCA parameters (only one of the two should
-   be set).  The values of these parameters can be a comma-delimited
-   list of network interfaces.  For example:
+#. To use TCP for MPI communication but restrict it to (or from)
+   certain networks, use the ``btl_tcp_if_include`` or
+   ``btl_tcp_if_exclude`` MCA parameter (only one of the two should be
+   set).  The value can be a comma-delimited list of network
+   interfaces.  For example:
 
    .. code-block:: sh
 
-      # This says to not use the eth0 and lo interfaces.
-      # (and implicitly use all the rest).  Per the description
-      # above, IP loopback and all local-only devices *must*
-      # be included if the exclude list is specified.
+      # Do not use the lo and eth0 interfaces (and implicitly use the
+      # rest).  Per the description above, IP loopback and all
+      # local-only devices *must* be included in an exclude list.
       shell$ mpirun --mca btl_tcp_if_exclude lo,eth0 ...
 
-      # This says to only use the eth1 and eth2 interfaces
-      # (and implicitly ignore the rest)
+      # Use only the eth1 and eth2 interfaces (and implicitly ignore
+      # the rest)
       shell$ mpirun --mca btl_tcp_if_include eth1,eth2 ...
 
-#. You can  also specify subnets  in the  include or exclude  lists in
-   CIDR notation.  For example:
+#. You can also specify subnets in the include or exclude lists in CIDR
+   notation.  For example:
 
    .. code-block:: sh
 
       # Only use the 192.168.1.0/24 and 10.10.0.0/16 subnets for MPI
-      # communications:
+      # communication
       shell$ mpirun --mca btl_tcp_if_include 192.168.1.0/24,10.10.0.0/16 ...
 
-
    .. note:: You must specify the CIDR notation for a given network
              precisely.  For example, if you have two IP networks
-             10.10.0.0/24 and 10.10.1.0/24, Open MPI will not
-             recognize either of them if you specify "10.10.0.0/16".
+             10.10.0.0/24 and 10.10.1.0/24, Open MPI will not recognize
+             either of them if you specify "10.10.0.0/16".
 
 .. warning:: If you use the ``btl_tcp_if_include`` and
-             ``btl_tcp_if_exclude`` MCA parameters to shape the
-             behavior of the TCP BTL for MPI communications, you may
-             also need/want to investigate the corresponding PRRTE
-             parameters that control use of network interfaces by the
-             runtime (e.g., communications setup and coordination
-             during :ref:`MPI_Init` and :ref:`MPI_Finalize`) using the
-             :ref:`prte_info(1) <prrte:man1-prte_info>`
-             and :ref:`pmix_info(1) <pmix:man1-pmix_info>` commands.
-
-Note that the Open MPI runtime uses TCP for control messages, such as
-for data exchange between ``mpirun(1)`` and the MPI processes,
-rendezvous information during :ref:`MPI_Init`, etc. even if the
-``tcp`` BTL component is disabled.
-
-/////////////////////////////////////////////////////////////////////////
+             ``btl_tcp_if_exclude`` MCA parameters to shape the behavior
+             of the TCP BTL for MPI communication, you may also
+             need/want to investigate the corresponding PRRTE parameters
+             that control use of network interfaces by the runtime (for
+             example, communication setup and coordination during
+             :ref:`MPI_Init` and :ref:`MPI_Finalize`), using the
+             :ref:`prte_info(1) <prrte:man1-prte_info>` and
+             :ref:`pmix_info(1) <pmix:man1-pmix_info>` commands.
+
+Note that the Open MPI runtime uses TCP for control messages |mdash|
+such as data exchange between ``mpirun(1)`` and the MPI processes,
+rendezvous information during :ref:`MPI_Init`, and so on |mdash| even if
+the ``tcp`` BTL component is disabled.
 
 .. _faq-tcp-sockets:
 
-Does Open MPI open a bunch of sockets during ``MPI_INIT``?
-----------------------------------------------------------
+Sockets opened during MPI_Init
+------------------------------
 
 Although Open MPI is likely to open multiple TCP sockets during
-``MPI_INIT``, the ``tcp`` BTL component *does not open one socket per
-MPI peer process during MPI_INIT.*  Open MPI opens sockets as they
-are required |mdash| so the first time a process sends a message to a
-peer and there is no TCP connection between the two, Open MPI will
-automatically open a new socket.
-
-Hence, you should not have scalability issues with running large
-numbers of processes (e.g., running out of per-process file
-descriptors) if your parallel application is sparse in its
+``MPI_Init``, the ``tcp`` BTL component *does not open one socket per
+MPI peer process during* ``MPI_Init``.  Open MPI opens sockets as they
+are required, so the first time a process sends a message to a peer and
+there is no TCP connection between the two, Open MPI automatically opens
+a new socket.
+
+As a result, you should not have scalability issues (such as running
+out of per-process file descriptors) when running large numbers of
+processes, provided your parallel application is sparse in its
 communication with peers.
 
-/////////////////////////////////////////////////////////////////////////
-
-Are there any Linux kernel TCP parameters that I should set?
-------------------------------------------------------------
+Recommended Linux kernel TCP parameters
+---------------------------------------
 
-Everyone has different opinions on this, and it also depends
-on your exact hardware and environment.  Below are general guidelines
-that some users have found helpful.
+Everyone has different opinions on this, and the best settings also
+depend on your exact hardware and environment.  The following are
+general guidelines that some users have found helpful.
 
 #. ``net.ipv4.tcp_syn_retries``: Some Linux systems have very large
    initial connection timeouts |mdash| they retry sending SYN packets
    many times before determining that a connection cannot be made.  If
-   MPI is going to fail to make socket connections, it would be better
-   for them to fail somewhat quickly (minutes vs. hours).  You might
-   want to reduce this value to a smaller value; YMMV.
+   MPI is going to fail to make socket connections, it is better for it
+   to fail somewhat quickly (minutes vs. hours), so you might want to
+   reduce this value; your mileage may vary.
 
 #. ``net.ipv4.tcp_keepalive_time``: Some MPI applications send an
    initial burst of MPI messages (over TCP) and then send nothing for
-   long periods of time (e.g., embarrassingly parallel applications).
-   Linux may decide that these dormant TCP sockets are dead because it
-   has seen no traffic on them for long periods of time.  You might
-   therefore need to lengthen the TCP inactivity timeout.  Many Linux
-   systems default to 7,200 seconds; increase it if necessary.
+   long periods of time (for example, embarrassingly parallel
+   applications).  Linux may decide that these dormant TCP sockets are
+   dead because it has seen no traffic on them for a long time.  You
+   might therefore need to lengthen the TCP inactivity timeout.  Many
+   Linux systems default to 7,200 seconds; increase it if necessary.
 
 #. Increase TCP buffering for 10G or 40G Ethernet.  Many Linux
-   distributions come with good buffering presets for 1G Ethernet.  In
-   a datacenter/HPC cluster with 10G or 40G Ethernet NICs, this amount
-   of kernel buffering is typically insufficient.  Here's a set of
-   parameters that some have used for good 10G/40G TCP bandwidth:
+   distributions come with good buffering presets for 1G Ethernet, but
+   in a datacenter/HPC cluster with 10G or 40G Ethernet NICs, this
+   amount of kernel buffering is typically insufficient.  Here is a set
+   of parameters that some have used for good 10G/40G TCP bandwidth:
 
    * ``net.core.rmem_max``: 16777216
    * ``net.core.wmem_max``: 16777216
@@ -327,62 +291,60 @@ that some users have found helpful.
    * ``net.ipv4.tcp_mem``: '16777216 16777216 16777216'
    * ``net.ipv4.route.flush``: 1
 
-   Each of the above items is a Linux kernel parameter that can be set
-   in multiple different ways.
+Each of the above is a Linux kernel parameter that can be set in
+several ways:
 
-   #. You can change the running kernel via the ``/proc`` filesystem:
+#. You can change the running kernel via the ``/proc`` filesystem:
 
-      .. code-block:: sh
-
-         shell# cat /proc/sys/net/ipv4/tcp_syn_retries
-         5
-         shell# echo 6 > /proc/sys/net/ipv4/tcp_syn_retries
+   .. code-block:: sh
 
-   #. You can also use the ``sysctl`` command:
+      shell# cat /proc/sys/net/ipv4/tcp_syn_retries
+      5
+      shell# echo 6 > /proc/sys/net/ipv4/tcp_syn_retries
 
-      .. code-block:: sh
+#. You can use the ``sysctl`` command:
 
-         shell# sysctl net.ipv4.tcp_syn_retries
-         net.ipv4.tcp_syn_retries = 5
-         shell# sysctl -w net.ipv4.tcp_syn_retries=6
-         net.ipv4.tcp_syn_retries = 6
+   .. code-block:: sh
 
-   #. Or you can set them by adding entries in ``/etc/sysctl.conf``,
-      which are persistent across reboots:
+      shell# sysctl net.ipv4.tcp_syn_retries
+      net.ipv4.tcp_syn_retries = 5
+      shell# sysctl -w net.ipv4.tcp_syn_retries=6
+      net.ipv4.tcp_syn_retries = 6
 
-      .. code-block:: sh
+#. You can set them persistently (across reboots) by adding entries in
+   ``/etc/sysctl.conf``:
 
-         shell$ grep tcp_syn_retries /etc/sysctl.conf
-         net.ipv4.tcp_syn_retries = 6
+   .. code-block:: sh
 
-   #. Your Linux distro may also support putting individual files in
-      ``/etc/sysctl.d`` (even if that directory does not yet exist),
-      which is actually better practice than putting them in
-      ``/etc/sysctl.conf``.  For example:
+      shell$ grep tcp_syn_retries /etc/sysctl.conf
+      net.ipv4.tcp_syn_retries = 6
 
-      .. code-block:: sh
+#. Your Linux distribution may also support putting individual files in
+   ``/etc/sysctl.d`` (even if that directory does not yet exist), which
+   is actually better practice than putting them in
+   ``/etc/sysctl.conf``.  For example:
 
-         shell$ cat /etc/sysctl.d/my-tcp-settings
-         net.ipv4.tcp_syn_retries = 6
+   .. code-block:: sh
 
-/////////////////////////////////////////////////////////////////////////
+      shell$ cat /etc/sysctl.d/my-tcp-settings
+      net.ipv4.tcp_syn_retries = 6
 
 .. _faq-tcp-routability:
 
-How does Open MPI know which IP addresses are routable to each other?
----------------------------------------------------------------------
+How Open MPI determines routability
+-----------------------------------
 
 Open MPI assumes that all interfaces are routable as long as they have
-the same address family, IPv4 or IPv6.  We use graph theory and give
+the same address family (IPv4 or IPv6).  It uses graph theory, giving
 each possible connection a weight depending on the quality of the
-connection.  This allows the library to select the best connections
-between nodes.  This method also supports striping but prevents more
+connection, which allows the library to select the best connections
+between nodes.  This method also supports striping, but prevents more
 than one connection to any interface.
 
-The quality of the connection is defined as follows, with a higher
-number meaning better connection.  Note that when giving a weight to a
-connection consisting of a private address and a public address, it
-will give it the weight of ``PRIVATE_DIFFERENT_NETWORK``.
+The quality of a connection is defined as follows, with a higher number
+meaning a better connection.  Note that a connection consisting of a
+private address and a public address is given the weight
+``PRIVATE_DIFFERENT_NETWORK``.
 
 .. code-block::
 
@@ -392,9 +354,8 @@ will give it the weight of ``PRIVATE_DIFFERENT_NETWORK``.
    PUBLIC_DIFFERENT_NETWORK  = 3
    PUBLIC_SAME_NETWORK       = 4
 
-An example will best illustrate how two processes on two different
-nodes would connect up.  Here we have two nodes with a variety of
-interfaces:
+An example best illustrates how two processes on two different nodes
+would connect.  Here we have two nodes with a variety of interfaces:
 
 .. code-block::
 
@@ -413,11 +374,11 @@ interfaces:
      | 192.168.2.2/24 |     |                |
       ----------------      ------------------
 
-From these two nodes, the software builds up a bipartite graph that
-shows all the possible connections with all the possible weights.  The
-*lo0* interfaces are excluded as the ``btl_tcp_if_exclude`` MCA parameter
-is set to *lo* by default.  Here is what all the possible connections
-with their weights look like.
+From these two nodes, the software builds a bipartite graph that shows
+all the possible connections with all the possible weights.  The
+``lo0`` interfaces are excluded because the ``btl_tcp_if_exclude`` MCA
+parameter is set to ``lo`` by default.  Here is what all the possible
+connections with their weights look like:
 
 .. code-block::
 
@@ -432,13 +393,12 @@ with their weights look like.
           ------- 1 -------- eth1
 
 The library then examines all the connections and picks the optimal
-ones.  This leaves us with two connections being established between
-the two nodes.
+ones.  This leaves two connections established between the two nodes.
 
 If you are curious about the actual ``connect()`` calls being made by
-the processes, then you can run with ``--mca btl_base_verbose 30``.
-This can be useful if you notice your job hanging and believe it may
-be the library trying to make connections to unreachable hosts.
+the processes, run with ``--mca btl_base_verbose 30``.  This can be
+useful if you notice your job hanging and believe it may be the library
+trying to make connections to unreachable hosts:
 
 .. code-block:: sh
 
@@ -451,117 +411,104 @@ be the library trying to make connections to unreachable hosts.
    [NodeB:16842] btl: tcp: attempting to connect() to address 192.168.1.1 on port 44500
    [...snip...]
 
-In case you want more details about the theory behind the connection
-code, you can find the background story in `this IEEE paper
+If you want more details about the theory behind the connection code,
+you can find the background story in `this IEEE paper
 <https://ieeexplore.ieee.org/document/4476565>`_.
 
-/////////////////////////////////////////////////////////////////////////
-
-Does Open MPI ever close TCP sockets?
--------------------------------------
+When Open MPI closes TCP sockets
+--------------------------------
 
-In general, no. However, there are some exceptions.
-
-Although TCP sockets are opened "lazily" (meaning that MPI
-connections / TCP sockets are only opened upon demand |mdash| as opposed to
+In general, Open MPI does not close TCP sockets; however, there are
+some exceptions.  Although TCP sockets are opened lazily (MPI
+connections / TCP sockets are only opened on demand, as opposed to
 opening all possible sockets between MPI peer processes during
-``MPI_INIT``), they are never closed unless the MPI world or MPI sessions
-are explicitly finalized or disconnected. For example, if the MPI world is
-finalized, all TCP sockets will be closed. If a spawned MPI process is
-disconnected, all TCP sockets to any parent MPI process will be closed.
-Similarly, if the MPI session is disconnected, all TCP sockets to any child
-MPI processes will be closed.
-
-/////////////////////////////////////////////////////////////////////////
+``MPI_Init``), they are never closed unless the MPI world or MPI
+sessions are explicitly finalized or disconnected.  For example, if the
+MPI world is finalized, all TCP sockets are closed.  If a spawned MPI
+process is disconnected, all TCP sockets to any parent MPI process are
+closed.  Similarly, if an MPI session is disconnected, all TCP sockets
+to any child MPI processes are closed.
 
-Does Open MPI support IP interfaces that have more than one IP address?
------------------------------------------------------------------------
+Interfaces with multiple IP addresses
+--------------------------------------
 
-In general, no.
-
-For example, if the output from your ``ifconfig`` has a single IP device
-with multiple IP addresses like this:
+In general, Open MPI does not support an IP interface that has more than
+one IP address.  For example, if the output from your ``ifconfig`` has a
+single IP device with multiple IP addresses like this:
 
 .. code-block::
 
    0: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP qlen 1000
       link/ether 00:18:ae:f4:d2:29 brd ff:ff:ff:ff:ff:ff
       inet 192.168.0.3/24 brd 192.168.0.255 scope global eth0:1
-      inet 10.10.0.3/24 brf 10.10.0.255 scope global eth0
+      inet 10.10.0.3/24 brd 10.10.0.255 scope global eth0
       inet6 fe80::218:aef2:29b4:2c4/64 scope link
          valid_lft forever preferred_lft forever
 
-(note the two ``inet`` lines in there)
-
-Then Open MPI will be unable to use this device.
-
-/////////////////////////////////////////////////////////////////////////
-
-Does Open MPI support virtual IP interfaces?
---------------------------------------------
-
-No.
-
-For example, if the output of your ``ifconfig`` has both ``eth0`` and
-``eth0:0``, Open MPI will get confused if you use the TCP BTL, and
-may hang or otherwise act unpredictably.
+(note the two ``inet`` lines), then Open MPI will be unable to use this
+device.
 
-Note that using ``btl_tcp_if_include`` or ``btl_tcp_if_exclude`` to avoid
-using the virtual interface will *not* solve the issue.
+Virtual IP interfaces
+---------------------
 
-/////////////////////////////////////////////////////////////////////////
+Open MPI does not support virtual IP interfaces.  For example, if the
+output of your ``ifconfig`` has both ``eth0`` and ``eth0:0``, Open MPI
+will get confused if you use the TCP BTL, and may hang or otherwise act
+unpredictably.  Note that using ``btl_tcp_if_include`` or
+``btl_tcp_if_exclude`` to avoid using the virtual interface will *not*
+solve the issue.
 
-Can I use multiple TCP connections to improve network performance?
-------------------------------------------------------------------
+Using multiple TCP connections
+------------------------------
 
 Open MPI can use multiple TCP connections between any pair of MPI
 processes, striping large messages across the connections.  The
-``btl_tcp_links`` parameter can be used to set how many TCP
-connections should be established between MPI processes.
-
-Note that
-this may not improve application performance for common use cases of
-nearest-neighbor exchanges when there many MPI processes on each host.  In
-these cases, there are already many TCP connections between any two
-hosts (because of the many processes all communicating), so the extra TCP
-connections are likely just consuming extra resources and adding work
-to the MPI implementation.
-
-However, for highly multi-threaded applications, where there are only
-one or two MPI processes per host, the ``btl_tcp_links`` option may
-improve TCP throughput considerably.
-
-/////////////////////////////////////////////////////////////////////////
-
-Can I limit the time spent on establishing TCP connections?
------------------------------------------------------------
-
-Yes. You can set the ``tcp_recv_timeout`` and ``tcp_handshake_timeout``
-MCA parameters to limit the time spent on establishing TCP connections.
-The difference between the two is subtle, but important: the
-``tcp_recv_timeout`` is the timeout for one receive operation
-while the ``tcp_handshake_timeout`` is the timeout for the entire handshake
-(i.e., the exchange of the correct magic string and process GUID). These two
-parameters can be used to avoid deadlocks in adversarial situations where
-external processes (e.g., not MPI processes part of any job) are trying to
-connect to the Open MPI process, and are holding the connection socket open
-without sending the proper handshake information.
-
-The default values are 250,000 usec for ``tcp_recv_timeout`` and 1,000,000
-usec for ``tcp_handshake_timeout``.
-
-For example:
+``btl_tcp_links`` parameter sets how many TCP connections are
+established between MPI processes.
+
+Note that this may not improve application performance for common use
+cases of nearest-neighbor exchanges when there are many MPI processes
+on each host.  In those cases, there are already many TCP connections
+between any two hosts (because of the many processes all communicating),
+so the extra TCP connections are likely just consuming extra resources
+and adding work to the MPI implementation.
+
+However, for highly multi-threaded applications where there are only one
+or two MPI processes per host, the ``btl_tcp_links`` option may improve
+TCP throughput considerably.
+
+Limiting the time spent establishing TCP connections
+-----------------------------------------------------
+
+You can set the ``btl_tcp_recv_timeout`` and
+``btl_tcp_handshake_timeout`` MCA parameters to limit the time spent
+establishing TCP connections.  The difference between the two is subtle
+but important: ``btl_tcp_recv_timeout`` is the timeout for one receive
+operation, while ``btl_tcp_handshake_timeout`` is the timeout for the
+entire handshake (that is, the exchange of the correct magic string and
+process GUID).  These parameters can be used to avoid deadlocks in
+adversarial situations where external processes (for example, processes
+that are not part of any MPI job) try to connect to the Open MPI process
+and hold the connection socket open without sending the proper handshake
+information.
+
+The default values are 250,000 usec for ``btl_tcp_recv_timeout`` and
+1,000,000 usec for ``btl_tcp_handshake_timeout``.  For example:
 
 .. code-block:: sh
 
-   shell$ mpirun --mca tcp_recv_timeout 1000000 ...
-   shell$ mpirun --mca tcp_handshake_timeout 1000000 ...
+   shell$ mpirun --mca btl_tcp_recv_timeout 1000000 ...
+   shell$ mpirun --mca btl_tcp_handshake_timeout 1000000 ...
 
-/////////////////////////////////////////////////////////////////////////
+Nagle's algorithm and TCP_NODELAY
+---------------------------------
 
-Can I use TCP_NODELAY to improve latency?
------------------------------------------
+By default, the TCP BTL disables Nagle's algorithm |mdash| that is, it
+sets the ``TCP_NODELAY`` socket option |mdash| which favors low latency
+for applications driven by waves of small messages.  Using Nagle's
+algorithm can increase short-message latency.
 
-If your application is driven by waves of small messages, you may be able
-to improve latency by enabling TCP_NODELAY. You can set the ``btl_tcp_use_nagle``
-MCA parameter to 1 to enable TCP_NODELAY.
+This behavior is controlled by the ``btl_tcp_use_nagle`` MCA parameter,
+which defaults to 0 (Nagle's algorithm disabled, ``TCP_NODELAY`` set).
+Set it to 1 to use Nagle's algorithm (clearing ``TCP_NODELAY``); this is
+rarely desirable for latency-sensitive workloads.
diff --git a/docs/validate-llm-docs.py b/docs/validate-llm-docs.py
new file mode 100755
index 00000000000..216409aa8a4
--- /dev/null
+++ b/docs/validate-llm-docs.py
@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2026 Jeffrey M. Squyres.  All rights reserved.
+#
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+"""Validate the generated LLM-friendly documentation artifacts.
+
+Run after generate-llm-docs.py (e.g. via "make check" in docs/).  Checks:
+
+* every JSONL catalog record validates against openmpi-mpi-api.schema.json;
+* the manifest validates against openmpi-docs-manifest.schema.json;
+* the cross-field invariant that each record's `languages` equals the distinct
+  `bindings[].language` set (JSON Schema cannot express this);
+* every record links back to the human docs (urls.html present);
+* generated Markdown contains no unresolved RST (`.. include::` directives,
+  `:ref:` roles, RST `\\`text <url>\\`_` hyperlinks, or man-page `|...|`
+  substitutions);
+* the manifest inventories every artifact except itself, with matching sha256
+  and byte size, and lists nothing that is missing on disk;
+* the committed sample records (specs/llms-friendly-docs/sample-records.jsonl)
+  validate against the schema and match the generated catalog by semantic
+  content, ignoring the per-build version stamp (docset) so the samples need
+  not be regenerated on every version bump and stay valid across branches;
+* every MPI Forum procedure that Open MPI actually implements has a man page,
+  so an implemented MPI API is never silently undocumented.
+
+Exits non-zero if any check fails.  Targets the Python 3.6 floor.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+
+try:
+    import jsonschema
+    # The schemas are JSON Schema draft 2020-12, which needs jsonschema >= 4
+    # (Python 3.7+). On the Python 3.6 floor only jsonschema 3.2.0 installs,
+    # and it lacks Draft202012Validator -- degrade gracefully there rather
+    # than crashing on the missing attribute.
+    HAVE_JSONSCHEMA = hasattr(jsonschema, 'Draft202012Validator')
+except ImportError:
+    HAVE_JSONSCHEMA = False
+
+# Unresolved-RST patterns that must NOT appear in generated Markdown.
+UNRESOLVED = [
+    (":ref: role", re.compile(r':ref:`')),
+    (".. include:: directive", re.compile(r'^\s*\.\.\s+include::', re.M)),
+    ("RST directive", re.compile(r'^\s*\.\.\s+[a-zA-Z0-9_-]+::', re.M)),
+    ("RST hyperlink", re.compile(r'`[^`]+<[^`>]+>`_')),
+    ("man-page substitution",
+     re.compile(r'\|(?:mdash|rarrow|deprecated_favor|ompi_ver|ompi_series|'
+                r'mpi_standard_version|mpi_standard_major_version|'
+                r'mpi_standard_minor_version)\|')),
+]
+
+
+def fail(errors, msg):
+    errors.append(msg)
+
+
+def read_text(path):
+    with open(path, encoding='utf-8') as fp:
+        return fp.read()
+
+
+def read_bytes(path):
+    with open(path, 'rb') as fp:
+        return fp.read()
+
+
+def read_json(path):
+    return json.loads(read_text(path))
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Validate LLM-friendly docs")
+    ap.add_argument('--srcdir', required=True, help='docs source dir')
+    ap.add_argument('--llms-dir', required=True,
+                    help='published/staged llms/ directory to validate')
+    ap.add_argument('--samples',
+                    help='path to sample-records.jsonl (optional)')
+    args = ap.parse_args()
+
+    srcdir = os.path.abspath(args.srcdir)
+    llms = os.path.abspath(args.llms_dir)
+    schema_dir = os.path.join(srcdir, 'llms-src')
+    errors = []
+
+    cat_validator = man_validator = None
+    if HAVE_JSONSCHEMA:
+        catalog_schema = read_json(
+            os.path.join(schema_dir, 'openmpi-mpi-api.schema.json'))
+        manifest_schema = read_json(
+            os.path.join(schema_dir, 'openmpi-docs-manifest.schema.json'))
+        jsonschema.Draft202012Validator.check_schema(catalog_schema)
+        jsonschema.Draft202012Validator.check_schema(manifest_schema)
+        cat_validator = jsonschema.Draft202012Validator(catalog_schema)
+        man_validator = jsonschema.Draft202012Validator(manifest_schema)
+    else:
+        print("  WARNING: jsonschema (>= 4, with Draft202012Validator) not "
+              "available; skipping JSON Schema validation (cross-field, "
+              "manifest, and Markdown checks still run). Install a recent "
+              "jsonschema for full validation.", file=sys.stderr)
+
+    # --- catalog records ---
+    catalog_path = os.path.join(llms, 'openmpi-mpi-api.jsonl')
+    catalog = {}
+    n_records = 0
+    for i, line in enumerate(read_text(catalog_path).split('\n'), 1):
+        line = line.rstrip('\n')
+        if not line:
+            continue
+        n_records += 1
+        rec = json.loads(line)
+        catalog[rec['name']] = line
+        if cat_validator:
+            for e in cat_validator.iter_errors(rec):
+                fail(errors, "catalog record {} ({}): {}".format(
+                    i, rec.get('name'), e.message))
+        # cross-field invariant
+        decl = sorted(rec['languages'])
+        present = sorted({b['language'] for b in rec['bindings']})
+        if decl != present:
+            fail(errors, "catalog record {}: languages {} != bindings langs {}"
+                 .format(rec['name'], decl, present))
+        # link-back
+        if not rec.get('urls', {}).get('html'):
+            fail(errors, "catalog record {}: missing urls.html".format(
+                rec['name']))
+        # docset must not carry build identity (that lives only in the manifest)
+        for bad in ('git_commit', 'git_describe', 'generated_at'):
+            if bad in rec.get('docset', {}):
+                fail(errors, "catalog record {}: docset contains build-identity "
+                     "field {}".format(rec['name'], bad))
+
+    # --- manifest ---
+    manifest_path = os.path.join(llms, 'openmpi-docs-manifest.json')
+    manifest = read_json(manifest_path)
+    if man_validator:
+        for e in man_validator.iter_errors(manifest):
+            fail(errors, "manifest: {}".format(e.message))
+
+    # --- manifest <-> on-disk consistency ---
+    # The published root is the parent of llms/ (llms.txt lives there too).
+    pub_root = os.path.dirname(llms)
+    manifest_rel = 'llms/openmpi-docs-manifest.json'
+    listed = set()
+    for art in manifest['artifacts']:
+        rel = art['path']
+        listed.add(rel)
+        if rel == manifest_rel:
+            fail(errors, "manifest lists itself ({})".format(rel))
+        full = os.path.join(pub_root, rel)
+        if not os.path.exists(full):
+            fail(errors, "manifest lists missing artifact: {}".format(rel))
+            continue
+        data = read_bytes(full)
+        if hashlib.sha256(data).hexdigest() != art['sha256']:
+            fail(errors, "manifest sha256 mismatch: {}".format(rel))
+        if len(data) != art['bytes']:
+            fail(errors, "manifest byte size mismatch: {}".format(rel))
+
+    # Every on-disk LLM artifact (everything under llms/, plus the top-level
+    # llms.txt) except the manifest must be listed.  Scope to the LLM tree so
+    # this works whether llms/ sits alone in a staging dir or inside the full
+    # Sphinx HTML output.
+    on_disk = set()
+    for root, _dirs, files in os.walk(llms):
+        for fn in files:
+            on_disk.add(os.path.relpath(os.path.join(root, fn), pub_root))
+    if os.path.exists(os.path.join(pub_root, 'llms.txt')):
+        on_disk.add('llms.txt')
+    for rel in sorted(on_disk):
+        if rel == manifest_rel:
+            continue
+        if rel not in listed:
+            fail(errors, "artifact on disk not in manifest: {}".format(rel))
+
+    # --- versioned llms.txt must be timestamp-free (so it is reproducible and
+    #     listable in the manifest) ---
+    llms_txt = os.path.join(pub_root, 'llms.txt')
+    if os.path.exists(llms_txt):
+        txt = read_text(llms_txt)
+        if re.search(r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}', txt) \
+                or 'generated_at' in txt:
+            fail(errors, "llms.txt contains a generation timestamp "
+                 "(it must be timestamp-free)")
+
+    # --- no unresolved RST in generated Markdown ---
+    for root, _dirs, files in os.walk(llms):
+        for fn in files:
+            if not fn.endswith('.md'):
+                continue
+            # Curated sources are hand-written Markdown, not RST-derived.
+            if fn in ('openmpi-mpi-interface-guide.md',
+                      'openmpi-mpi-examples.md',
+                      'openmpi-runtime-introspection.md'):
+                continue
+            text = read_text(os.path.join(root, fn))
+            for label, pat in UNRESOLVED:
+                if pat.search(text):
+                    fail(errors, "{}: unresolved {}".format(fn, label))
+
+    # --- sample records ---
+    samples = args.samples or os.path.join(
+        srcdir, '..', 'specs', 'llms-friendly-docs', 'sample-records.jsonl')
+    if os.path.exists(samples):
+        for i, line in enumerate(read_text(samples).split('\n'), 1):
+            line = line.rstrip('\n')
+            if not line:
+                continue
+            rec = json.loads(line)
+            if cat_validator:
+                for e in cat_validator.iter_errors(rec):
+                    fail(errors, "sample {} ({}): {}".format(
+                        i, rec.get('name'), e.message))
+            if rec['name'] not in catalog:
+                fail(errors, "sample {} not in generated catalog".format(
+                    rec['name']))
+            else:
+                # Compare the sample against the generated record by semantic
+                # content, ignoring the docset field.  docset carries the
+                # per-build Open MPI version and series (e.g. ompi_version
+                # "v6.1.0a1", ompi_series "v6.1.x"): a single global stamp,
+                # identical across every record, that changes on every version
+                # bump, branch, and release.  Comparing it byte-for-byte would
+                # force the committed samples to be regenerated every time the
+                # version changes, and -- worse -- would tie a sample file to a
+                # single branch's VERSION, so cherry-picking this check to a
+                # release branch (whose VERSION differs from main) would always
+                # fail here even though the API content is identical.  The
+                # version is not API content; its shape is still validated
+                # against the schema above, schema_version is also a top-level
+                # record field that remains compared here, and any formatting or
+                # key-ordering drift in the catalog file is caught separately by
+                # the manifest sha256/byte-size check.  So drop docset from both
+                # sides and compare the rest.
+                gen = {k: v for k, v in json.loads(catalog[rec['name']]).items()
+                       if k != 'docset'}
+                smp = {k: v for k, v in rec.items() if k != 'docset'}
+                if gen != smp:
+                    fail(errors, "sample {} differs from generated catalog "
+                         "record (regenerate the samples)".format(rec['name']))
+
+    # --- coverage: an implemented MPI API must have a man page ---
+    # A procedure in the MPI Forum metadata that Open MPI actually implements
+    # must have a man page; otherwise it is silently absent from the rendered
+    # HTML docs, the installed Unix man pages, and these artifacts.  Whether a
+    # procedure is "implemented" is read from the public C header
+    # (ompi/include/mpi.h.in) and, for Fortran-only routines such as
+    # MPI_F_sync_reg, from the use-mpi-f08 sources.  Procedures the MPI Standard
+    # defines but Open MPI does not implement are intentionally not flagged.
+    # Skipped (with a warning) when pympistandard or the ompi/ source tree is
+    # unavailable, e.g. a docs-only checkout.
+    top_srcdir = os.path.dirname(srcdir)
+    mpih = os.path.join(top_srcdir, 'ompi', 'include', 'mpi.h.in')
+    std = None
+    try:
+        import ompi_docs_common as common
+        std = common.load_pympistandard(srcdir)
+    except Exception as exc:
+        print("  WARNING: pympistandard unavailable ({}); skipping "
+              "implemented-API man-page coverage check".format(exc),
+              file=sys.stderr)
+    if std is not None and not os.path.exists(mpih):
+        print("  WARNING: {} not found; skipping implemented-API man-page "
+              "coverage check".format(mpih), file=sys.stderr)
+    elif std is not None:
+        directives = common.read_rst_man_pages(srcdir)
+        documented = set(directives)
+        for procs in directives.values():
+            documented.update(procs)
+        undocumented = [p for p in sorted(std.PROCEDURES)
+                        if p not in documented]
+        if undocumented:
+            mpih_l = read_text(mpih).lower()
+            f08_parts = []
+            f08_dir = os.path.join(top_srcdir, 'ompi', 'mpi', 'fortran',
+                                   'use-mpi-f08')
+            for root, _dirs, files in os.walk(f08_dir):
+                for fn in files:
+                    if fn.endswith(('.F90', '.f90', '.h', '.in')):
+                        f08_parts.append(
+                            read_text(os.path.join(root, fn)).lower())
+            f08_l = '\n'.join(f08_parts)
+            for proc in undocumented:
+                in_c = re.search(r'\b' + re.escape(proc) + r'\s*\(', mpih_l)
+                in_f08 = re.search(r'\b' + re.escape(proc) + r'_f08\b', f08_l)
+                if not (in_c or in_f08):
+                    continue
+                p = std.PROCEDURES[proc]
+                binding = (common.c_binding(p) or common.f08_binding(p)
+                           or common.f90_binding(p) or '')
+                m = re.search(r'(MPI[A-Za-z0-9_]*)\s*\(', binding)
+                pname = m.group(1) if m else proc
+                fail(errors, "implemented MPI API has no man page: {0} "
+                     "(add docs/man-openmpi/man3/{0}.3.rst)".format(pname))
+
+    if errors:
+        print("LLM docs validation FAILED ({} error(s)):".format(len(errors)),
+              file=sys.stderr)
+        for e in errors[:50]:
+            print("  - {}".format(e), file=sys.stderr)
+        if len(errors) > 50:
+            print("  ... and {} more".format(len(errors) - 50), file=sys.stderr)
+        sys.exit(1)
+
+    print("  CHECK LLM docs: OK ({} records, manifest + samples validated)"
+          .format(n_records))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/version-numbering.rst b/docs/version-numbering.rst
index b96da23de91..00fbdd426bc 100644
--- a/docs/version-numbering.rst
+++ b/docs/version-numbering.rst
@@ -67,7 +67,7 @@ format.  Each of the three numbers has a specific meaning:
   change in the code base and/or end-user functionality, and also
   indicate a break from backward compatibility.  Specifically: Open
   MPI releases with different major version numbers are not
-  backward compatibale with each other.
+  backward compatible with each other.
 
   .. important:: This rule does not extend to versions prior to
      v1.10.0.  Specifically: v1.10.x is not guaranteed to be backward
@@ -163,7 +163,6 @@ Here's how we apply those rules specifically to Open MPI:
    * ``libmpi_usempi_ignore_tkr``
    * ``libmpi_usempif08``
    * ``libmpi_cxx``
-   * ``libmpi_java``
    * ``liboshmem``
 
 API and ABI Compatibility
diff --git a/examples/Connectivity.java b/examples/Connectivity.java
deleted file mode 100644
index 551a56ad188..00000000000
--- a/examples/Connectivity.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Test the connectivity between all processes
- */
-
-import mpi.*;
-import java.nio.IntBuffer;
-
-class Connectivity {
-    public static void main(String args[]) throws MPIException {
-         MPI.Init(args);
- 
-         /*
-          * MPI.COMM_WORLD is the communicator provided when MPI is
-          * initialized. It contains all the processes that are created
-          * upon program execution.
-          */
-         int myRank = MPI.COMM_WORLD.getRank();
-         int numProcesses = MPI.COMM_WORLD.getSize();
-         boolean verbose = false;
-         String processorName = MPI.getProcessorName();
- 
-         for (String arg : args) {
-             if (arg.equals("-v") || arg.equals("--verbose")) {
-                 verbose = true;
-                 break;
-             }
-         }
- 
-         for (int i = 0; i < numProcesses; i++) {
-             /* Find current process */
-             if (myRank == i) {
-                 /* send to and receive from all higher ranked processes */
-                 for (int j = i + 1; j < numProcesses; j++) {
-                     if (verbose)
-                         System.out.printf("Checking connection between rank %d on %s and rank %d\n", i, processorName,
-                                j);
- 
-                     /*
-                      * rank is the Buffer passed into sendRecv to send to rank j.
-                      * rank is populated with myRank, which is the data to send off
-                      * peer is the Buffer received from rank j to current rank
-                      */
-                     IntBuffer rank = MPI.newIntBuffer(1);
-                     IntBuffer peer = MPI.newIntBuffer(1);
-                     rank.put(0, myRank);
- 
-                     /*
-                      * To avoid deadlocks, use combined sendRecv operation.
-                      * This performs a send and recv as a combined atomic operation
-                      * and allow MPI to efficiently handle the requests internally.
-                      */
-                     MPI.COMM_WORLD.sendRecv(rank, 1, MPI.INT, j, myRank, peer, 1, MPI.INT, j, j);
-                 }
-             } else if (myRank > i) {
-                 IntBuffer rank = MPI.newIntBuffer(1);
-                 IntBuffer peer = MPI.newIntBuffer(1);
-                 rank.put(0, myRank);
- 
-                 /* receive from and reply to rank i */
-                 MPI.COMM_WORLD.sendRecv(rank, 1, MPI.INT, i, myRank, peer, 1, MPI.INT, i, i);
-             }
-         }
- 
-         /* Wait for all processes to reach barrier before proceeding */
-         MPI.COMM_WORLD.barrier();
- 
-         /*
-          * Once all ranks have reached the barrier,
-          * have only one process print out the confirmation message.
-          * In this case, we are having the "master" process print the message.
-          */
-         if (myRank == 0) {
-             System.out.printf("Connectivity test on %d processes PASSED.\n", numProcesses);
-         }
- 
-         MPI.Finalize();
-     }
-}
\ No newline at end of file
diff --git a/examples/Hello.java b/examples/Hello.java
deleted file mode 100644
index cd7c5268fa2..00000000000
--- a/examples/Hello.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       https://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * Author of revised version: Franklyn Pinedo
- *
- * Adapted from Source Code in C of Tutorial/User's Guide for MPI by
- * Peter Pacheco.
- */
-/*
- * Copyright (c) 2011      Cisco Systems, Inc.  All rights reserved.
- *
- */
-
-import mpi.*;
-
-class Hello {
-    static public void main(String[] args) throws MPIException {
-
-
-	MPI.Init(args);
-
-	int myrank = MPI.COMM_WORLD.getRank();
-	int size = MPI.COMM_WORLD.getSize() ;
-	System.out.println("Hello world from rank " + myrank + " of " + size);
-
-	MPI.Finalize();
-    }
-}
diff --git a/examples/Makefile b/examples/Makefile
index 735b911923d..3616a617400 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -15,6 +15,7 @@
 # Copyright (c) 2013      Mellanox Technologies, Inc.  All rights reserved.
 # Copyright (c) 2017-2018 Research Organization for Information Science
 #                         and Technology (RIST). All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -26,7 +27,6 @@
 
 MPICC = mpicc
 MPIFC = mpifort
-MPIJAVAC = mpijavac
 SHMEMCC = shmemcc
 SHMEMCXX = shmemc++
 SHMEMFC = shmemfort
@@ -51,16 +51,13 @@ EXAMPLES = \
 	 hello_oshmem \
 	 hello_oshmemcxx \
 	 hello_oshmemfh \
-	 Hello.class \
 	 ring_c \
 	 ring_mpifh \
 	 ring_usempi \
 	 ring_usempif08 \
 	 ring_oshmem \
 	 ring_oshmemfh \
-	 Ring.class \
 	 connectivity_c \
-	 Connectivity.class \
 	 oshmem_shmalloc \
 	 oshmem_circular_shift \
 	 oshmem_max_reduction \
@@ -74,7 +71,7 @@ EXAMPLES = \
 # others if we have the appropriate Open MPI / OpenSHMEM language
 # bindings.
 
-all: hello_c ring_c connectivity_c spc_example hello_sessions_c
+all: hello_c ring_c connectivity_c hello_sessions_c
 	@ if which ompi_info >/dev/null 2>&1 ; then \
 	    $(MAKE) mpi; \
 	fi
@@ -94,8 +91,8 @@ mpi:
 	@ if ompi_info --parsable | grep -q bindings:use_mpi_f08:yes >/dev/null; then \
 	    $(MAKE) hello_usempif08 ring_usempif08; \
 	fi
-	@ if ompi_info --parsable | grep -q bindings:java:yes >/dev/null; then \
-	    $(MAKE) Hello.class Ring.class; \
+	@ if ompi_info --parsable | grep -q enable-spc >/dev/null; then \
+	    $(MAKE) spc_example; \
 	fi
 
 # OpenSHMEM examples
@@ -121,7 +118,7 @@ oshmem:
 clean:
 	rm -f $(EXAMPLES) *~ *.o
 
-# Don't rely on default rules for the Fortran and Java examples
+# Don't rely on default rules for the Fortran examples
 
 hello_c: hello_c.c
 	$(MPICC) $(CFLAGS) $(LDFLAGS) $? $(LDLIBS) -o $@
@@ -149,11 +146,6 @@ hello_usempif08: hello_usempif08.f90
 ring_usempif08: ring_usempif08.f90
 	$(MPIFC) $(FCFLAGS) $(LDFLAGS) $? $(LDLIBS) -o $@
 
-Hello.class: Hello.java
-	$(MPIJAVAC) Hello.java
-Ring.class: Ring.java
-	$(MPIJAVAC) Ring.java
-
 hello_oshmem: hello_oshmem_c.c
 	$(SHMEMCC) $(CFLAGS) $(LDFLAGS) $? $(LDLIBS) -o $@
 hello_oshmemcxx: hello_oshmem_cxx.cc
diff --git a/examples/Makefile.include b/examples/Makefile.include
index 8da106cb507..1fe536d669b 100644
--- a/examples/Makefile.include
+++ b/examples/Makefile.include
@@ -16,6 +16,7 @@
 # Copyright (c) 2013      Mellanox Technologies, Inc.  All rights reserved.
 # Copyright (c) 2017      Research Organization for Information Science
 #                         and Technology (RIST). All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -54,7 +55,5 @@ EXTRA_DIST += \
         examples/oshmem_max_reduction.c \
         examples/oshmem_strided_puts.c \
         examples/oshmem_symmetric_data.c \
-        examples/Hello.java \
-        examples/Ring.java \
         examples/spc_example.c \
         examples/hello_sessions_c.c
diff --git a/examples/README.md b/examples/README.md
index 6a1ab9528cb..ec6e2e23e2e 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -21,7 +21,6 @@ The MPI version of the canonical "hello world" program:
 * Fortran mpif.h: `hello_mpifh.f`
 * Fortran use mpi: `hello_usempi.f90`
 * Fortran use mpi_f08: `hello_usempif08.f90`
-* Java: `Hello.java`
 * C shmem.h: `hello_oshmem_c.c`
 * Fortran shmem.fh: `hello_oshmemfh.f90`
 
@@ -34,7 +33,6 @@ Send a trivial message around in a ring:
 * Fortran mpif.h: `ring_mpifh.f`
 * Fortran use mpi: `ring_usempi.f90`
 * Fortran use mpi_f08: `ring_usempif08.f90`
-* Java: `Ring.java`
 * C shmem.h: `ring_oshmem_c.c`
 * Fortran shmem.fh: `ring_oshmemfh.f90`
 
diff --git a/examples/Ring.java b/examples/Ring.java
deleted file mode 100644
index 6aa3770e21b..00000000000
--- a/examples/Ring.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2011      Cisco Systems, Inc.  All rights reserved.
- *
- * Simple ring test program
- */
-
-import mpi.* ;
-
-class Ring {
-    static public void main(String[] args) throws MPIException {
-
-
-	MPI.Init(args) ;
-
-	int source;  // Rank of sender
-	int dest;    // Rank of receiver
-	int tag=50;  // Tag for messages
-	int next;
-	int prev;
-	int message[] = new int [1];
-
-	int myrank = MPI.COMM_WORLD.getRank() ;
-	int size = MPI.COMM_WORLD.getSize() ;
-
-	/* Calculate the rank of the next process in the ring.  Use the
-	   modulus operator so that the last process "wraps around" to
-	   rank zero. */
-
-	next = (myrank + 1) % size;
-	prev = (myrank + size - 1) % size;
-
-	/* If we are the "manager" process (i.e., MPI_COMM_WORLD rank 0),
-	   put the number of times to go around the ring in the
-	   message. */
-
-	if (0 == myrank) {
-	    message[0] = 10;
-
-	    System.out.println("Process 0 sending " + message[0] + " to rank " + next + " (" + size + " processes in ring)");
-	    MPI.COMM_WORLD.send(message, 1, MPI.INT, next, tag);
-	}
-
-	/* Pass the message around the ring.  The exit mechanism works as
-	   follows: the message (a positive integer) is passed around the
-	   ring.  Each time it passes rank 0, it is decremented.  When
-	   each processes receives a message containing a 0 value, it
-	   passes the message on to the next process and then quits.  By
-	   passing the 0 message first, every process gets the 0 message
-	   and can quit normally. */
-
-	while (true) {
-	    MPI.COMM_WORLD.recv(message, 1, MPI.INT, prev, tag);
-
-	    if (0 == myrank) {
-		--message[0];
-		System.out.println("Process 0 decremented value: " + message[0]);
-	    }
-
-	    MPI.COMM_WORLD.send(message, 1, MPI.INT, next, tag);
-	    if (0 == message[0]) {
-		System.out.println("Process " + myrank + " exiting");
-		break;
-	    }
-	}
-
-	/* The last process does one extra send to process 0, which needs
-	   to be received before the program can exit */
-
-	if (0 == myrank) {
-	    MPI.COMM_WORLD.recv(message, 1, MPI.INT, prev, tag);
-	}
-
-	MPI.Finalize();
-    }
-}
diff --git a/ompi/Makefile.am b/ompi/Makefile.am
index f855492ef15..79f992e7b35 100644
--- a/ompi/Makefile.am
+++ b/ompi/Makefile.am
@@ -21,7 +21,7 @@
 # Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
 # Copyright (c) 2021      Amazon.com, Inc. or its affiliates.  All Rights
 #                         reserved.
-# Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2025-2026 Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -94,10 +94,11 @@ SUBDIRS = \
         mpi/fortran/mpiext-use-mpi-f08 \
         $(MCA_ompi_FRAMEWORK_COMPONENT_DSO_SUBDIRS)
 
-if OMPI_WANT_JAVA_BINDINGS
+# Unit tests for the OMPI layer.  Placed at the end of SUBDIRS so that
+# libmpi (built by the "." entry above) exists before the test programs
+# are linked during "make check".
 SUBDIRS += \
-        mpi/java
-endif
+        test
 
 # The ordering of the DIST_SUBDIRS isn't as important, but note that
 # its contents *are* different than SUBDIRS.  In particular, the
@@ -121,7 +122,7 @@ DIST_SUBDIRS = \
         mpi/fortran/use-mpi-f08/mod \
         mpi/fortran/use-mpi-f08/bindings \
         mpi/fortran/mpiext-use-mpi-f08 \
-        mpi/java \
+        test \
         $(OMPI_MPIEXT_ALL_SUBDIRS) \
         $(MCA_ompi_FRAMEWORKS_SUBDIRS) \
         $(MCA_ompi_FRAMEWORK_COMPONENT_ALL_SUBDIRS)
diff --git a/ompi/attribute/attribute.c b/ompi/attribute/attribute.c
index d224f4b8793..3654b43a23c 100644
--- a/ompi/attribute/attribute.c
+++ b/ompi/attribute/attribute.c
@@ -136,8 +136,9 @@
  *          -> *ret will equal 7.
  *
  * 5. Fortran MPI-1 reads the attribute value.  The C int value is
- *    cast to a fortran INTEGER (i.e., MPI_Fint) -- potentially being
- *    truncated if sizeof(int) > sizeof(INTEGER).
+ *    cast to a fortran INTEGER (i.e., MPI_Fint).  configure requires
+ *    sizeof(INTEGER) >= sizeof(int) (see OMPI_SETUP_MPI_FORTRAN), so
+ *    this conversion is always exact.
  *
  * Example: INTEGER ret
  *          CALL MPI_ATTR_GET(..., ret, ierr)
diff --git a/ompi/attribute/attribute_predefined.c b/ompi/attribute/attribute_predefined.c
index 3bc1849dc52..781bdbb70dd 100644
--- a/ompi/attribute/attribute_predefined.c
+++ b/ompi/attribute/attribute_predefined.c
@@ -143,6 +143,9 @@ int ompi_attr_create_predefined_keyvals(void)
             OMPI_SUCCESS != (rc = create_win(MPI_WIN_CREATE_FLAVOR)) ||
             OMPI_SUCCESS != (rc = create_win(MPI_WIN_MODEL)) ||
             OMPI_SUCCESS != (rc = create_comm(MPI_FT, false)) || /* not #if conditional on OPAL_ENABLE_FT_MPI for ABI */
+            OMPI_SUCCESS != (rc = create_win(MPI_WIN_NOTIFICATION_NUM_SB)) ||
+            OMPI_SUCCESS != (rc = create_win(MPI_WIN_NOTIFICATION_NUM_UB)) ||
+            OMPI_SUCCESS != (rc = create_win(MPI_WIN_NOTIFICATION_VALUE_UB)) ||
             0) {
             ret = rc;
         }
@@ -227,7 +230,10 @@ int ompi_attr_free_predefined(void)
             OMPI_SUCCESS != (rc = free_win(MPI_WIN_SIZE)) ||
             OMPI_SUCCESS != (rc = free_win(MPI_WIN_DISP_UNIT)) ||
             OMPI_SUCCESS != (rc = free_win(MPI_WIN_CREATE_FLAVOR)) ||
-            OMPI_SUCCESS != (rc = free_win(MPI_WIN_MODEL))) {
+            OMPI_SUCCESS != (rc = free_win(MPI_WIN_MODEL)) ||
+            OMPI_SUCCESS != (rc = free_win(MPI_WIN_NOTIFICATION_NUM_SB)) ||
+            OMPI_SUCCESS != (rc = free_win(MPI_WIN_NOTIFICATION_NUM_UB)) ||
+            OMPI_SUCCESS != (rc = free_win(MPI_WIN_NOTIFICATION_VALUE_UB))) {
             ret = rc;
         }
 
diff --git a/ompi/communicator/comm.c b/ompi/communicator/comm.c
index ce51aa7336a..78d491683d7 100644
--- a/ompi/communicator/comm.c
+++ b/ompi/communicator/comm.c
@@ -28,6 +28,7 @@
  *                         reserved.
  * Copyright (c) 2023-2025 Advanced Micro Devices, Inc. All rights reserved.
  * Copyright (c) 2025      BULL S.A.S. All rights reserved.
+ * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -40,6 +41,8 @@
 #include <stdio.h>
 
 #include "ompi/constants.h"
+#include "opal/mca/accelerator/accelerator.h"
+#include "opal/mca/base/mca_base_var.h"
 #include "opal/mca/hwloc/base/base.h"
 #include "opal/mca/pmix/pmix-internal.h"
 #include "opal/util/string_copy.h"
@@ -64,6 +67,7 @@
 struct ompi_comm_split_type_hw_guided_t {
     const char *info_value;
     int split_type;
+    bool use_for_unguided;
 };
 typedef struct ompi_comm_split_type_hw_guided_t ompi_comm_split_type_hw_guided_t;
 
@@ -73,18 +77,19 @@ typedef struct ompi_comm_split_type_hw_guided_t ompi_comm_split_type_hw_guided_t
  * the order in this array must be from largest topology class to smallest.
  */
 static const ompi_comm_split_type_hw_guided_t ompi_comm_split_type_hw_guided_support[] = {
-    {.info_value = "cluster",  .split_type = OMPI_COMM_TYPE_CLUSTER},
-    {.info_value = "cu",       .split_type = OMPI_COMM_TYPE_CU},
-    {.info_value = "host",     .split_type = OMPI_COMM_TYPE_HOST},
-    {.info_value = "mpi_shared_memory", .split_type = MPI_COMM_TYPE_SHARED},
-    {.info_value = "board",    .split_type = OMPI_COMM_TYPE_BOARD},
-    {.info_value = "numanode", .split_type = OMPI_COMM_TYPE_NUMA},
-    {.info_value = "socket",   .split_type = OMPI_COMM_TYPE_SOCKET},
-    {.info_value = "l3cache",  .split_type = OMPI_COMM_TYPE_L3CACHE},
-    {.info_value = "l2cache",  .split_type = OMPI_COMM_TYPE_L2CACHE},
-    {.info_value = "l1cache",  .split_type = OMPI_COMM_TYPE_L1CACHE},
-    {.info_value = "core",     .split_type = OMPI_COMM_TYPE_CORE},
-    {.info_value = "hwthread", .split_type = OMPI_COMM_TYPE_HWTHREAD},
+    {.info_value = "cluster",  .split_type = OMPI_COMM_TYPE_CLUSTER,  .use_for_unguided = false},
+    {.info_value = "nvlink",   .split_type = OMPI_COMM_TYPE_NVLINK,   .use_for_unguided = false},
+    {.info_value = "cu",       .split_type = OMPI_COMM_TYPE_CU,       .use_for_unguided = true},
+    {.info_value = "host",     .split_type = OMPI_COMM_TYPE_HOST,     .use_for_unguided = true},
+    {.info_value = "mpi_shared_memory", .split_type = MPI_COMM_TYPE_SHARED, .use_for_unguided = true},
+    {.info_value = "board",    .split_type = OMPI_COMM_TYPE_BOARD,    .use_for_unguided = true},
+    {.info_value = "numanode", .split_type = OMPI_COMM_TYPE_NUMA,     .use_for_unguided = true},
+    {.info_value = "socket",   .split_type = OMPI_COMM_TYPE_SOCKET,   .use_for_unguided = true},
+    {.info_value = "l3cache",  .split_type = OMPI_COMM_TYPE_L3CACHE,  .use_for_unguided = true},
+    {.info_value = "l2cache",  .split_type = OMPI_COMM_TYPE_L2CACHE,  .use_for_unguided = true},
+    {.info_value = "l1cache",  .split_type = OMPI_COMM_TYPE_L1CACHE,  .use_for_unguided = true},
+    {.info_value = "core",     .split_type = OMPI_COMM_TYPE_CORE,     .use_for_unguided = true},
+    {.info_value = "hwthread", .split_type = OMPI_COMM_TYPE_HWTHREAD, .use_for_unguided = true},
     {.info_value = NULL},
 };
 
@@ -278,10 +283,14 @@ int ompi_comm_set_nb (ompi_communicator_t **ncomm, ompi_communicator_t *oldcomm,
             /* NTH: use internal idup function that takes a local group argument */
             ompi_comm_idup_internal (old_localcomm, newcomm->c_local_group, NULL, NULL,
                                      &newcomm->c_local_comm, req);
+            if (NULL != newcomm->c_local_comm
+                && !OMPI_COMM_IS_INTRINSIC(newcomm->c_local_comm)) {
+                OBJ_RETAIN(newcomm->c_local_comm);
+            }
         } else {
-            /* take ownership of the old communicator (it must be an intracommunicator) */
             assert (OMPI_COMM_IS_INTRA(oldcomm));
             newcomm->c_local_comm = oldcomm;
+            OBJ_RETAIN(newcomm->c_local_comm);
         }
     } else {
         newcomm->c_remote_group = newcomm->c_local_group;
@@ -832,6 +841,7 @@ static int ompi_comm_split_type_get_part (ompi_group_t *group, const int split_t
         case OMPI_COMM_TYPE_CLUSTER:
             include = OPAL_PROC_ON_LOCAL_CLUSTER(locality);
             break;
+        case OMPI_COMM_TYPE_NVLINK:
         case MPI_COMM_TYPE_HW_GUIDED:
         case MPI_COMM_TYPE_HW_UNGUIDED:
         case MPI_COMM_TYPE_RESOURCE_GUIDED:
@@ -913,6 +923,270 @@ static int ompi_comm_split_verify (ompi_communicator_t *comm, int split_type, in
     return OMPI_SUCCESS;
 }
 
+static int ompi_comm_split_type_nvlink_domain_compare(const void *a, const void *b)
+{
+    return memcmp(a, b, OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN);
+}
+
+static int ompi_comm_split_type_nvlink_hex_nibble(char digit)
+{
+    if ('0' <= digit && digit <= '9') {
+        return digit - '0';
+    }
+    if ('a' <= digit && digit <= 'f') {
+        return digit - 'a' + 10;
+    }
+    if ('A' <= digit && digit <= 'F') {
+        return digit - 'A' + 10;
+    }
+    return -1;
+}
+
+static int ompi_comm_split_type_parse_nvlink_domain(
+    const char *value, opal_accelerator_cuda_nvlink_domain_t *domain)
+{
+    char uuid_string[2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN + 1] = {0};
+    unsigned int clique_id;
+    int cuda_device;
+    int end = 0;
+
+    if (NULL == value ||
+        3 != sscanf(value, "cuda_device=%d,cluster_uuid=%32[0123456789abcdefABCDEF],clique_id=%u%n",
+                    &cuda_device, uuid_string, &clique_id, &end) ||
+        '\0' != value[end] ||
+        2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN != strlen(uuid_string)) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    domain->cuda_device = cuda_device;
+    domain->clique_id = (uint32_t) clique_id;
+    for (int i = 0; i < OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN; ++i) {
+        int high = ompi_comm_split_type_nvlink_hex_nibble(uuid_string[2 * i]);
+        int low = ompi_comm_split_type_nvlink_hex_nibble(uuid_string[2 * i + 1]);
+
+        if (0 > high || 0 > low) {
+            return OMPI_ERR_BAD_PARAM;
+        }
+        domain->cluster_uuid[i] = (uint8_t) ((high << 4) | low);
+    }
+
+    return OMPI_SUCCESS;
+}
+
+static int ompi_comm_split_type_get_nvlink_domain(
+    opal_accelerator_cuda_nvlink_domain_t *domain)
+{
+    char **value = NULL;
+    int var_id, rc;
+
+    domain->cuda_device = MCA_ACCELERATOR_NO_DEVICE_ID;
+    memset(domain->cluster_uuid, 0, sizeof(domain->cluster_uuid));
+    domain->clique_id = 0;
+
+    /* The CUDA accelerator owns the cache and exposes it through this
+     * read-only MCA variable. If CUDA did not register or fill it, the default
+     * no-device domain above keeps the split color MPI_UNDEFINED. */
+    var_id = mca_base_var_find("opal", "accelerator", NULL, "nvlink_domain");
+    if (0 > var_id) {
+        return OMPI_ERR_NOT_FOUND;
+    }
+
+    rc = mca_base_var_get_value(var_id, &value, NULL, NULL);
+    if (OMPI_SUCCESS != rc || NULL == value) {
+        return rc;
+    }
+
+    return ompi_comm_split_type_parse_nvlink_domain(*value, domain);
+}
+
+#if OPAL_ENABLE_DEBUG
+static void ompi_comm_split_type_nvlink_uuid_to_hex(
+    const uint8_t uuid[OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN],
+    char hex_uuid[2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN + 1])
+{
+    static const char hex[] = "0123456789abcdef";
+
+    for (int i = 0; i < OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN; ++i) {
+        hex_uuid[2 * i] = hex[uuid[i] >> 4];
+        hex_uuid[2 * i + 1] = hex[uuid[i] & 0x0f];
+    }
+    hex_uuid[2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN] = '\0';
+}
+#endif
+
+#define OMPI_COMM_SPLIT_TYPE_NVLINK_UUID_WORDS 4
+#define OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS OMPI_COMM_SPLIT_TYPE_NVLINK_UUID_WORDS
+#define OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_SIZE \
+    (OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS * sizeof(int))
+
+static int ompi_comm_split_type_nvlink(ompi_communicator_t *comm, int local_split_type,
+                                       opal_info_t *info, ompi_communicator_t **newcomm)
+{
+    opal_accelerator_cuda_nvlink_domain_t my_domain = {
+        .cuda_device = MCA_ACCELERATOR_NO_DEVICE_ID,
+    };
+    int my_token[OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS] = {0};
+    int *domains = NULL;
+    int local_size = ompi_comm_size(comm), remote_size = 0, max_domains;
+    int inter, send_first = 0, local_offset = 0, remote_offset = 0;
+    int color = MPI_UNDEFINED, rc = OMPI_SUCCESS;
+    bool have_domain = false;
+
+    /* The allgather payload is only the 16-byte color identifier, carried as
+     * MPI_INTs through the split-time allgather/broadcast exchange. The
+     * communicator uses the MCA-backed NVLink domain cache exactly as stored.
+     * Its default is an all-zero UUID with cuda_device set to
+     * MCA_ACCELERATOR_NO_DEVICE_ID; ranks in that state still enter the
+     * collective exchange with a zero token, but keep MPI_UNDEFINED as their
+     * split color because the default does not imply an NVLink domain. Only the
+     * CUDA accelerator may replace NVML's active single-node all-zero
+     * clusterUuid with a hostname-derived token.
+     */
+    inter = OMPI_COMM_IS_INTER(comm);
+    if (inter) {
+        remote_size = ompi_comm_remote_size(comm);
+        send_first = ompi_comm_determine_first_auto(comm);
+        if (send_first) {
+            remote_offset = local_size * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+        } else {
+            local_offset = remote_size * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+        }
+    }
+
+    max_domains = local_size + remote_size;
+    domains = malloc(max_domains * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_SIZE);
+    /* Do not add a collective allocation check here: all ranks must enter the
+     * same split-time allgather sequence. For now assume the local allocations
+     * succeed. */
+
+    if (MPI_UNDEFINED != local_split_type) {
+        (void) ompi_comm_split_type_get_nvlink_domain(&my_domain);
+        if (MCA_ACCELERATOR_NO_DEVICE_ID != my_domain.cuda_device) {
+            memcpy(my_token, my_domain.cluster_uuid,
+                   OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_SIZE);
+            have_domain = true;
+        }
+    }
+
+    rc = comm->c_coll->coll_allgather(my_token,
+                                      OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS,
+                                      MPI_INT, domains + remote_offset,
+                                      OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS,
+                                      MPI_INT, comm,
+                                      comm->c_coll->coll_allgather_module);
+    if (OMPI_SUCCESS != rc) {
+        goto failure;
+    }
+
+    if (inter) {
+        int local_root = 0 == ompi_comm_rank(comm) ? MPI_ROOT : MPI_PROC_NULL;
+        int *bcast_domains;
+        int bcast_count, bcast_root;
+
+        /* Intercommunicator allgather gives each group the peer group's tokens.
+         * Use the deterministic send_first value to establish one global order
+         * for the domains array on both groups: all ranks from the "first" side
+         * followed by all ranks from the "second" side. The allgather writes
+         * the peer block directly into its final global-order position. The two
+         * broadcasts then send each peer block back to its owning side so every
+         * process ends with an identical domains[] layout. The conditional
+         * expressions below pick the block, count, and root for each direction:
+         * first the second-side block, then the first-side block. This common
+         * order is what lets the color assignment below avoid sorting. */
+        bcast_domains = domains + (send_first ? remote_offset : local_offset);
+        bcast_count = (send_first ? remote_size : local_size)
+                      * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+        bcast_root = send_first ? local_root : 0;
+        rc = comm->c_coll->coll_bcast(bcast_domains, bcast_count, MPI_INT,
+                                      bcast_root, comm,
+                                      comm->c_coll->coll_bcast_module);
+        if (OMPI_SUCCESS != rc) {
+            goto failure;
+        }
+
+        bcast_domains = domains + (send_first ? local_offset : remote_offset);
+        bcast_count = (send_first ? local_size : remote_size)
+                      * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+        bcast_root = send_first ? 0 : local_root;
+        rc = comm->c_coll->coll_bcast(bcast_domains, bcast_count, MPI_INT,
+                                      bcast_root, comm,
+                                      comm->c_coll->coll_bcast_module);
+        if (OMPI_SUCCESS != rc) {
+            goto failure;
+        }
+    }
+
+#if OPAL_ENABLE_DEBUG
+    for (int i = 0; i < max_domains; ++i) {
+        int *domain = domains + i * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+        char hex_uuid[2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN + 1];
+
+        ompi_comm_split_type_nvlink_uuid_to_hex((const uint8_t *) domain,
+                                                hex_uuid);
+        OPAL_OUTPUT_VERBOSE((10, ompi_comm_output, "rank %d: nvlink domain[%d] uuid=%s",
+                             ompi_comm_rank(comm), i, hex_uuid));
+    }
+#endif
+
+    if (have_domain) {
+        int unique_count = 0;
+
+        /* Build the color map in global domain order without sorting. The
+         * domains array is identical on all processes after the exchange above,
+         * so the first occurrence of each token is globally deterministic.
+         *
+         * As we scan domains[], keep the unique tokens compacted in the prefix
+         * domains[0..unique_count). A candidate token is unique only if it does
+         * not match any token already in that prefix. Once a candidate is known
+         * to be unique, check whether it is the local token before moving it
+         * into domains[unique_count]; unique_count is then exactly the color for
+         * that token. Stop as soon as the local token is assigned, because later
+         * colors do not affect this process. */
+        for (int i = 0; MPI_UNDEFINED == color && i < max_domains; ++i) {
+            int *domain = domains + i * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+            int *unique_domain = domains + unique_count * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+            bool seen = false;
+
+            for (int j = 0; j < unique_count; ++j) {
+                int *prior_domain = domains + j * OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_INTS;
+
+                if (0 == ompi_comm_split_type_nvlink_domain_compare(domain, prior_domain)) {
+                    seen = true;
+                    break;
+                }
+            }
+
+            if (seen) {
+                continue;
+            }
+
+            if (0 == ompi_comm_split_type_nvlink_domain_compare(my_token, domain)) {
+                color = unique_count;
+                /* We only need to enumerate colors up to the local process'
+                 * NVLink domain. */
+                break;
+            }
+            if (domain != unique_domain) {
+                memcpy(unique_domain, domain, OMPI_COMM_SPLIT_TYPE_NVLINK_TOKEN_SIZE);
+            }
+            ++unique_count;
+        }
+    }
+
+    free(domains);
+
+    return ompi_comm_split_with_info(comm, color, (int) my_domain.clique_id, info, newcomm,
+                                     false);
+
+failure:
+    /* Reaching this path means the split-time collective exchange failed, so
+     * the collective behavior of this function is already compromised. A future
+     * failure path should revoke the input communicator and return MPI_COMM_NULL
+     * as the new communicator. */
+    free(domains);
+    return ompi_comm_split_with_info(comm, MPI_UNDEFINED, 0, info, newcomm, false);
+}
+
 /**
  * ompi_comm_split_type_core: Perform common processing for a MPI_Comm_type_split
  *                            function call.
@@ -1116,13 +1390,16 @@ static int ompi_comm_split_unguided(ompi_communicator_t *comm, int split_type, i
      * calling ompi_comm_split_type specifying the split type as
      * MPI_COMM_TYPE_HW_GUIDED using the next lower topology class until a
      * split results in a smaller size communicator than the input communicator.
-     * The search starts with OMPI_COMM_TYPE_CU since that is the highest possible
-     * topology class where the communicator size can be smaller than MPI_COMM_WORLD.
      */
     original_size = ompi_comm_size(unguided_comm);
     split_info = OBJ_NEW(opal_info_t);
-    i = 1;
+    i = 0;
     while (NULL != ompi_comm_split_type_hw_guided_support[i].info_value) {
+        if (!ompi_comm_split_type_hw_guided_support[i].use_for_unguided) {
+            i = i + 1;
+            continue;
+        }
+
         /* MPI_COMM_TYPE_HW_GUIDED splits require mpi_hw_resource_type to be set */
         opal_info_set(split_info, "mpi_hw_resource_type",
                       ompi_comm_split_type_hw_guided_support[i].info_value);
@@ -1305,6 +1582,8 @@ int ompi_comm_split_type (ompi_communicator_t *comm, int split_type, int key,
         return ompi_comm_split_unguided( comm, split_type,
                                          key, need_split, no_reorder,
                                          no_undefined, info, newcomm );
+    } else if (OMPI_COMM_TYPE_NVLINK == global_split_type) {
+        return ompi_comm_split_type_nvlink(comm, split_type, info, newcomm);
     } else {
         return ompi_comm_split_type_core( comm, global_split_type, split_type,
                                           key, need_split, no_reorder,
@@ -2169,8 +2448,6 @@ static int ompi_comm_allgather_emulate_intra( void *inbuf, int incount,
 int ompi_comm_free( ompi_communicator_t **comm )
 {
     int ret;
-    int cid = (*comm)->c_index;
-    int is_extra_retain = OMPI_COMM_IS_EXTRA_RETAIN(*comm);
 
     /* Release attributes.  We do this now instead of during the
        communicator destructor for 2 reasons:
@@ -2199,7 +2476,9 @@ int ompi_comm_free( ompi_communicator_t **comm )
     }
 
     if ( OMPI_COMM_IS_INTER(*comm) ) {
-        if ( ! OMPI_COMM_IS_INTRINSIC((*comm)->c_local_comm)) {
+        if (NULL != (*comm)->c_local_comm
+            && ! OMPI_COMM_IS_INTRINSIC((*comm)->c_local_comm)) {
+            OBJ_RELEASE((*comm)->c_local_comm);
             ompi_comm_free (&(*comm)->c_local_comm);
         }
     }
@@ -2222,29 +2501,6 @@ int ompi_comm_free( ompi_communicator_t **comm )
     }
     OBJ_RELEASE( (*comm) );
 
-    if ( is_extra_retain) {
-        /* This communicator has been marked as an "extra retain"
-         * communicator. This can happen if a communicator creates
-         * 'dependent' subcommunicators (e.g. for inter
-         * communicators or when using hierarch collective
-         * module *and* the cid of the dependent communicator
-         * turned out to be lower than of the parent one.
-         * In that case, the reference counter has been increased
-         * by one more, in order to handle the scenario,
-         * that the user did not free the communicator.
-         * Note, that if we enter this routine, we can
-         * decrease the counter by one more therefore. However,
-         * in ompi_comm_finalize, we only used OBJ_RELEASE instead
-         * of ompi_comm_free(), and the increased reference counter
-         * makes sure that the pointer to the dependent communicator
-         * still contains a valid object.
-         */
-        ompi_communicator_t *tmpcomm = ompi_comm_lookup(cid);
-        if ( NULL != tmpcomm ){
-            ompi_comm_free(&tmpcomm);
-        }
-    }
-
     *comm = MPI_COMM_NULL;
     return OMPI_SUCCESS;
 }
diff --git a/ompi/communicator/comm_cid.c b/ompi/communicator/comm_cid.c
index ddf1657b9ab..86df2f6e48a 100644
--- a/ompi/communicator/comm_cid.c
+++ b/ompi/communicator/comm_cid.c
@@ -26,6 +26,7 @@
  * Copyright (c) 2021      Nanook Consulting.  All rights reserved.
  * Copyright (c) 2020-2026 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -60,8 +61,6 @@
 /* for use when we don't have a PMIx that supports CID generation */
 opal_atomic_int64_t ompi_comm_next_base_cid = 1;
 
-/* A macro comparing two CIDs */
-#define OMPI_COMM_CID_IS_LOWER(comm1,comm2) ( ((comm1)->c_index < (comm2)->c_index)? 1:0)
 
 struct ompi_comm_cid_context_t;
 
@@ -926,30 +925,6 @@ static int ompi_comm_activate_complete (ompi_comm_cid_context_t *context)
         return ret;
     }
 
-    /* For an inter communicator, we have to deal with the potential
-     * problem of what is happening if the local_comm that we created
-     * has a lower CID than the parent comm. This is not a problem
-     * as long as the user calls MPI_Comm_free on the inter communicator.
-     * However, if the communicators are not freed by the user but released
-     * by Open MPI in MPI_Finalize, we walk through the list of still available
-     * communicators and free them one by one. Thus, local_comm is freed before
-     * the actual inter-communicator. However, the local_comm pointer in the
-     * inter communicator will still contain the 'previous' address of the local_comm
-     * and thus this will lead to a segmentation violation. In order to prevent
-     * that from happening, we increase the reference counter local_comm
-     * by one if its CID is lower than the parent. We cannot increase however
-     *  its reference counter if the CID of local_comm is larger than
-     * the CID of the inter communicators, since a regular MPI_Comm_free would
-     * leave in that the case the local_comm hanging around and thus we would not
-     * recycle CID's properly, which was the reason and the cause for this trouble.
-     */
-    if (OMPI_COMM_IS_INTER(*newcomm)) {
-        if (OMPI_COMM_CID_IS_LOWER(*newcomm, comm)) {
-            OMPI_COMM_SET_EXTRA_RETAIN (*newcomm);
-            OBJ_RETAIN (*newcomm);
-        }
-    }
-
     /* done */
     return OMPI_SUCCESS;
 }
diff --git a/ompi/communicator/comm_init.c b/ompi/communicator/comm_init.c
index e348fb364d3..8cec884d24a 100644
--- a/ompi/communicator/comm_init.c
+++ b/ompi/communicator/comm_init.c
@@ -26,7 +26,7 @@
  * Copyright (c) 2018-2024 Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2023-2024 Advanced Micro Devices, Inc. All rights reserved.
- * Copyright (c) 2023      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2023-2026 NVIDIA Corporation.  All rights reserved.
  * Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
@@ -343,9 +343,6 @@ static int ompi_comm_finalize (void)
         /* tear down MPI-3 predefined communicators (not initialized unless using MPI_Init) */
         OBJ_DESTRUCT( &ompi_mpi_comm_self );
         ompi_attr_delete_predefined_keyvals_for_wm();
-        /* Destroy the keyhash even is user defined attributes are still attached. */
-        OBJ_DESTRUCT(ompi_mpi_comm_world.comm.c_keyhash);
-        ompi_mpi_comm_world.comm.c_keyhash = NULL;
         OBJ_DESTRUCT( &ompi_mpi_comm_world );
 
         ompi_comm_intrinsic_init = false;
@@ -388,31 +385,26 @@ static int ompi_comm_finalize (void)
     for ( i=3; i<max; i++ ) {
         comm = ompi_comm_lookup(i);
         if ( NULL != comm ) {
-            /* Communicator has not been freed before finalize */
+            /* Release the communicator. Sub-communicators retained by
+             * their parent (e.g., c_local_comm of inter-communicators)
+             * will be properly released by the parent's destructor. */
             OBJ_RELEASE(comm);
+        }
+    }
+
+#if OPAL_ENABLE_DEBUG
+    if ( ompi_debug_show_handle_leaks ) {
+        max = ompi_comm_get_num_communicators();
+        for ( i=3; i<max; i++ ) {
             comm = ompi_comm_lookup(i);
-            if ( NULL != comm ) {
-                /* Still here ? */
-                if ( !OMPI_COMM_IS_EXTRA_RETAIN(comm)) {
-
-                    /* For communicator that have been marked as "extra retain", we do not further
-                     * enforce to decrease the reference counter once more. These "extra retain"
-                     * communicators created e.g. by the hierarch or inter module did increase
-                     * the reference count by one more than other communicators, on order to
-                     * allow for deallocation with the parent communicator. Note, that
-                     * this only occurs if the cid of the local_comm is lower than of its
-                     * parent communicator. Read the comment in comm_activate for
-                     * a full explanation.
-                     */
-                    if ( ompi_debug_show_handle_leaks && !(OMPI_COMM_IS_FREED(comm)) ){
-                        opal_output(0,"WARNING: MPI_Comm still allocated in MPI_Finalize\n");
-                        ompi_comm_dump ( comm);
-                        OBJ_RELEASE(comm);
-                    }
-                }
-            }
+            if (NULL == comm) continue;
+            opal_output(0, "WARNING: %u(%s) unnamed MPI_Comm handles still allocated at MPI_FINALIZE",
+                        ompi_comm_get_local_cid(comm), comm->c_name);
+            ompi_comm_dump ( comm);
+            OBJ_RELEASE(comm);
         }
     }
+#endif  /* OPAL_ENABLE_DEBUG */
 
     OBJ_DESTRUCT (&ompi_mpi_communicators);
     OBJ_DESTRUCT (&ompi_comm_hash);
@@ -521,12 +513,24 @@ static void ompi_comm_destruct(ompi_communicator_t* comm)
         MCA_PML_CALL(del_comm (comm));
     }
 
+    /* Release the attributes */
+    if( NULL != comm->c_keyhash) {
+        OBJ_RELEASE(comm->c_keyhash);
+        comm->c_keyhash = NULL;
+    }
+
     /* Release topology module */
     if (NULL != comm->c_topo) {
         OBJ_RELEASE(comm->c_topo);
         comm->c_topo = NULL;
     }
 
+    if (OMPI_COMM_IS_INTER(comm) && NULL != comm->c_local_comm
+        && !OMPI_COMM_IS_INTRINSIC(comm->c_local_comm)) {
+        OBJ_RELEASE(comm->c_local_comm);
+        comm->c_local_comm = NULL;
+    }
+
     if (NULL != comm->c_local_group) {
         OBJ_RELEASE ( comm->c_local_group );
         comm->c_local_group = NULL;
diff --git a/ompi/communicator/communicator.h b/ompi/communicator/communicator.h
index 914230702d5..3e0958cebc6 100644
--- a/ompi/communicator/communicator.h
+++ b/ompi/communicator/communicator.h
@@ -25,7 +25,7 @@
  * Copyright (c) 2018-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2023      Advanced Micro Devices, Inc. All rights reserved.
- * Copyright (c) 2024      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2024-2026 NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -69,7 +69,6 @@ OMPI_DECLSPEC OBJ_CLASS_DECLARATION(ompi_communicator_t);
 #define OMPI_COMM_GRAPH        0x00000200
 #define OMPI_COMM_DIST_GRAPH   0x00000400
 #define OMPI_COMM_PML_ADDED    0x00001000
-#define OMPI_COMM_EXTRA_RETAIN 0x00004000
 #define OMPI_COMM_MAPBY_NODE   0x00008000
 #define OMPI_COMM_GLOBAL_INDEX 0x00010000
 
@@ -86,7 +85,6 @@ OMPI_DECLSPEC OBJ_CLASS_DECLARATION(ompi_communicator_t);
 #define OMPI_COMM_IS_DISJOINT_SET(comm) ((comm)->c_flags & OMPI_COMM_DISJOINT_SET)
 #define OMPI_COMM_IS_DISJOINT(comm) ((comm)->c_flags & OMPI_COMM_DISJOINT)
 #define OMPI_COMM_IS_PML_ADDED(comm) ((comm)->c_flags & OMPI_COMM_PML_ADDED)
-#define OMPI_COMM_IS_EXTRA_RETAIN(comm) ((comm)->c_flags & OMPI_COMM_EXTRA_RETAIN)
 #define OMPI_COMM_IS_TOPO(comm) (OMPI_COMM_IS_CART((comm)) || \
                                  OMPI_COMM_IS_GRAPH((comm)) || \
                                  OMPI_COMM_IS_DIST_GRAPH((comm)))
@@ -97,7 +95,6 @@ OMPI_DECLSPEC OBJ_CLASS_DECLARATION(ompi_communicator_t);
 #define OMPI_COMM_SET_INVALID(comm) ((comm)->c_flags |= OMPI_COMM_INVALID)
 
 #define OMPI_COMM_SET_PML_ADDED(comm) ((comm)->c_flags |= OMPI_COMM_PML_ADDED)
-#define OMPI_COMM_SET_EXTRA_RETAIN(comm) ((comm)->c_flags |= OMPI_COMM_EXTRA_RETAIN)
 #define OMPI_COMM_SET_MAPBY_NODE(comm) ((comm)->c_flags |= OMPI_COMM_MAPBY_NODE)
 
 #define OMPI_COMM_ASSERT_NO_ANY_TAG     0x00000001
@@ -148,8 +145,6 @@ OMPI_DECLSPEC OBJ_CLASS_DECLARATION(ompi_communicator_t);
  */
 #define OMPI_COMM_SENTINEL        0x00000001
 
-/* A macro comparing two CIDs */
-#define OMPI_COMM_CID_IS_LOWER(comm1,comm2) ( ((comm1)->c_index < (comm2)->c_index)? 1:0)
 
 OMPI_DECLSPEC extern opal_hash_table_t ompi_comm_hash;
 OMPI_DECLSPEC extern opal_pointer_array_t ompi_mpi_communicators;
diff --git a/ompi/datatype/ompi_datatype.h b/ompi/datatype/ompi_datatype.h
index 495609d9a7b..c9ae0018513 100644
--- a/ompi/datatype/ompi_datatype.h
+++ b/ompi/datatype/ompi_datatype.h
@@ -13,6 +13,7 @@
  * Copyright (c) 2021      IBM Corporation. All rights reserved.
  * Copyright (c) 2025      Triad National Security, LLC. All rights reserved.
  * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -41,6 +42,7 @@
 #include "ompi/constants.h"
 #include "opal/datatype/opal_convertor.h"
 #include "opal/util/output.h"
+#include "ompi/util/count_disp_array.h"
 #include "mpi.h"
 
 BEGIN_C_DECLS
@@ -125,7 +127,7 @@ OMPI_DECLSPEC int32_t ompi_datatype_default_convertors_init( void );
 OMPI_DECLSPEC int32_t ompi_datatype_default_convertors_fini( void );
 
 OMPI_DECLSPEC void ompi_datatype_dump (const ompi_datatype_t* pData);
-OMPI_DECLSPEC ompi_datatype_t* ompi_datatype_create( int32_t expectedSize );
+OMPI_DECLSPEC ompi_datatype_t* ompi_datatype_create( size_t expectedSize );
 
 static inline int32_t
 ompi_datatype_is_committed( const ompi_datatype_t* type )
@@ -152,7 +154,7 @@ ompi_datatype_is_predefined( const ompi_datatype_t* type )
 }
 
 static inline int32_t
-ompi_datatype_is_contiguous_memory_layout( const ompi_datatype_t* type, int32_t count )
+ompi_datatype_is_contiguous_memory_layout( const ompi_datatype_t* type, size_t count )
 {
     return opal_datatype_is_contiguous_memory_layout(&type->super, count);
 }
@@ -190,27 +192,27 @@ ompi_datatype_add( ompi_datatype_t* pdtBase, const ompi_datatype_t* pdtAdd, size
 OMPI_DECLSPEC int32_t
 ompi_datatype_duplicate( const ompi_datatype_t* oldType, ompi_datatype_t** newType );
 
-OMPI_DECLSPEC int32_t ompi_datatype_create_contiguous( int count, const ompi_datatype_t* oldType, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_vector( int count, int bLength, int stride,
+OMPI_DECLSPEC int32_t ompi_datatype_create_contiguous( size_t count, const ompi_datatype_t* oldType, ompi_datatype_t** newType );
+OMPI_DECLSPEC int32_t ompi_datatype_create_vector( size_t count, size_t bLength, ptrdiff_t stride,
                                                    const ompi_datatype_t* oldType, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_hvector( int count, int bLength, ptrdiff_t stride,
+OMPI_DECLSPEC int32_t ompi_datatype_create_hvector( size_t count, size_t bLength, ptrdiff_t stride,
                                                     const ompi_datatype_t* oldType, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_indexed( int count, const int* pBlockLength, const int* pDisp,
+OMPI_DECLSPEC int32_t ompi_datatype_create_indexed( size_t count, const ompi_count_array_t pBlockLength, const ompi_disp_array_t pDisp,
                                                     const ompi_datatype_t* oldType, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_hindexed( int count, const int* pBlockLength, const ptrdiff_t* pDisp,
+OMPI_DECLSPEC int32_t ompi_datatype_create_hindexed( size_t count, const ompi_count_array_t pBlockLength, const ompi_disp_array_t pDisp,
                                                      const ompi_datatype_t* oldType, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_indexed_block( int count, int bLength, const int* pDisp,
+OMPI_DECLSPEC int32_t ompi_datatype_create_indexed_block( size_t count, size_t bLength, const ompi_disp_array_t pDisp,
                                                           const ompi_datatype_t* oldType, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_hindexed_block( int count, int bLength, const ptrdiff_t* pDisp,
+OMPI_DECLSPEC int32_t ompi_datatype_create_hindexed_block( size_t count, size_t bLength, const ompi_disp_array_t pDisp,
                                                            const ompi_datatype_t* oldType, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_struct( int count, const int* pBlockLength, const ptrdiff_t* pDisp,
+OMPI_DECLSPEC int32_t ompi_datatype_create_struct( size_t count, const ompi_count_array_t pBlockLength, const ompi_disp_array_t pDisp,
                                                    ompi_datatype_t* const* pTypes, ompi_datatype_t** newType );
-OMPI_DECLSPEC int32_t ompi_datatype_create_darray( int size, int rank, int ndims, int const* gsize_array,
-                                                   int const* distrib_array, int const* darg_array,
-                                                   int const* psize_array, int order, const ompi_datatype_t* oldtype,
+OMPI_DECLSPEC int32_t ompi_datatype_create_darray( int size, int rank, int ndims, const ompi_count_array_t gsize_array,
+                                                   const int* distrib_array, const int* darg_array,
+                                                   const int* psize_array, int order, const ompi_datatype_t* oldtype,
                                                    ompi_datatype_t** newtype);
-OMPI_DECLSPEC int32_t ompi_datatype_create_subarray(int ndims, int const* size_array, int const* subsize_array,
-                                                    int const* start_array, int order,
+OMPI_DECLSPEC int32_t ompi_datatype_create_subarray(int ndims, const ompi_count_array_t size_array, const ompi_count_array_t subsize_array,
+                                                    const ompi_count_array_t start_array, int order,
                                                     const ompi_datatype_t* oldtype, ompi_datatype_t** newtype);
 static inline int32_t
 ompi_datatype_create_resized( const ompi_datatype_t* oldType,
@@ -297,25 +299,26 @@ ompi_datatype_copy_content_same_ddt( const ompi_datatype_t* type, size_t count,
     return 0;
 }
 
-OMPI_DECLSPEC const ompi_datatype_t* ompi_datatype_match_size( int size, uint16_t datakind, uint16_t datalang );
+OMPI_DECLSPEC const ompi_datatype_t* ompi_datatype_match_size( size_t size, uint16_t datakind, uint16_t datalang );
 
 /*
  *
  */
-OMPI_DECLSPEC int32_t ompi_datatype_sndrcv( const void *sbuf, int32_t scount, const ompi_datatype_t* sdtype,
-                                            void *rbuf, int32_t rcount, const ompi_datatype_t* rdtype);
+OMPI_DECLSPEC int32_t ompi_datatype_sndrcv( const void *sbuf, size_t scount, const ompi_datatype_t* sdtype,
+                                            void *rbuf, size_t rcount, const ompi_datatype_t* rdtype);
 
 /*
  *
  */
 OMPI_DECLSPEC int32_t ompi_datatype_get_args( const ompi_datatype_t* pData, int32_t which,
-                                              int32_t * ci, int32_t * i,
-                                              int32_t * ca, ptrdiff_t* a,
-                                              int32_t * cd, ompi_datatype_t** d, int32_t * type);
+                                              size_t * ci, int* i,
+                                              size_t * cl, MPI_Count* l,
+                                              size_t * ca, ptrdiff_t* a,
+                                              size_t * cd, ompi_datatype_t** d, int32_t * type);
 OMPI_DECLSPEC int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
-                                              int32_t ci, const int32_t ** i,
-                                              int32_t ca, const ptrdiff_t* a,
-                                              int32_t cd, ompi_datatype_t* const * d,int32_t type);
+                                              size_t ci, size_t cl, const ompi_count_array_t *counts,
+                                              size_t ca, const ompi_disp_array_t a,
+                                              size_t cd, ompi_datatype_t* const * d,int32_t type);
 OMPI_DECLSPEC int32_t ompi_datatype_copy_args( const ompi_datatype_t* source_data,
                                                ompi_datatype_t* dest_data );
 OMPI_DECLSPEC int32_t ompi_datatype_release_args( ompi_datatype_t* pData );
diff --git a/ompi/datatype/ompi_datatype_args.c b/ompi/datatype/ompi_datatype_args.c
index 22e3c3f51f2..98a95d2ef92 100644
--- a/ompi/datatype/ompi_datatype_args.c
+++ b/ompi/datatype/ompi_datatype_args.c
@@ -16,6 +16,8 @@
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2017      IBM Corporation. All rights reserved.
+ * Copyright (c) 2025-2026 Stony Brook University.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -41,60 +43,73 @@ static inline int
 __ompi_datatype_pack_description( ompi_datatype_t* datatype,
                                   void** packed_buffer, int* next_index );
 static ompi_datatype_t*
-__ompi_datatype_create_from_args( int32_t* i, ptrdiff_t * a,
+__ompi_datatype_create_from_args( const int* i, const size_t *l, const ptrdiff_t * a,
                                   ompi_datatype_t** d, int32_t type );
 
 typedef struct __dt_args {
     opal_atomic_int32_t ref_count;
     int32_t            create_type;
     size_t             total_pack_size;
-    int32_t            ci;
-    int32_t            ca;
-    int32_t            cd;
-    int*               i;
-    ptrdiff_t* a;
-    ompi_datatype_t**  d;
+    size_t             ci;
+    size_t             ca;
+    size_t             cd;
+    size_t             cl;
+    ptrdiff_t*          a;
+    ompi_datatype_t**   d;
+    size_t*             l; // array of size_t counts
+    int*                i; // array of integer counts
 } ompi_datatype_args_t;
 
 /**
- * Some architectures really don't like having unaligned
- * accesses.  We'll be int aligned, because any sane system will
- * require that.  But we might not be long aligned, and some
- * architectures will complain if a long is accessed on int
- * alignment (but not long alignment).  On those architectures,
- * copy the buffer into an aligned buffer first.
+ * The packed datatype description interleaves 32-bit ints with word-size
+ * (size_t / ptrdiff_t) values.  After writing an int the running pointer is
+ * only int-aligned, so accessing the following word-size value through it is
+ * an unaligned access -- which is undefined behavior and faults on
+ * strict-alignment architectures (e.g. RISC-V).  Realign the pointer up to
+ * word size before every word-size access.  The pack and unpack paths apply
+ * this identically, so the on-the-wire layout stays consistent.
  */
-#if OPAL_ALIGN_WORD_SIZE_INTEGERS
 #define OMPI_DATATYPE_ALIGN_PTR(PTR, TYPE) \
     (PTR) = OPAL_ALIGN_PTR((PTR), sizeof(ptrdiff_t), TYPE)
-#else
-#define OMPI_DATATYPE_ALIGN_PTR(PTR, TYPE)
-#endif  /* OPAL_ALIGN_WORD_SIZE_INTEGERS */
+
+/**
+ * Copies count elements from the given count array into either
+ * the integer or size_t destination depending on whether the
+ * count array is 32 or 64 bit. Advances the destination pointer.
+ */
+static inline void copy_count_array(size_t count, int**__restrict__ desti, size_t**__restrict__ destc, ompi_count_array_t array) {
+    size_t elem_size = opal_count_array_is_64bit(array) ? sizeof(size_t) : sizeof(int);
+    void *dest = opal_count_array_is_64bit(array) ? (void*)*destc : (void*)*desti;
+    memcpy(dest, opal_count_array_ptr(array), count * elem_size);
+    if (opal_count_array_is_64bit(array)) {
+        *destc += count;
+    } else {
+        *desti += count;
+    }
+}
 
 int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
-                                int32_t ci, const int32_t** i,
-                                int32_t ca, const ptrdiff_t* a,
-                                int32_t cd, ompi_datatype_t* const * d, int32_t type)
+                                size_t ci, size_t cl, const ompi_count_array_t *counts,
+                                size_t ca, const opal_disp_array_t a,
+                                size_t cd, ompi_datatype_t* const * d, int32_t type)
 {
-    int pos;
+    size_t pos;
 
     assert( NULL == pData->args );
-    int length = sizeof(ompi_datatype_args_t) + ci * sizeof(int) +
-                 ca * sizeof(ptrdiff_t) + cd * sizeof(MPI_Datatype);
+
+    size_t length = sizeof(ompi_datatype_args_t) + ci * sizeof(int) +
+                    cl * sizeof(size_t) + ca * sizeof(ptrdiff_t) +
+                    cd * sizeof(MPI_Datatype);
     char* buf = (char*)malloc( length );
     ompi_datatype_args_t* pArgs = (ompi_datatype_args_t*)buf;
+    size_t *pl = NULL;
+    int *pi = NULL;
     pArgs->ci = ci; pArgs->i = NULL;
+    pArgs->cl = cl; pArgs->l = NULL;
     pArgs->ca = ca; pArgs->a = NULL;
     pArgs->cd = cd; pArgs->d = NULL;
     pArgs->create_type = type;
 
-    /**
-     * Some architectures require 64 bits pointers (to pointers) to
-     * be 64 bits aligned. As in the ompi_datatype_args_t structure we have
-     * 2 such array of pointers and one to an array of ints, if we start by
-     * setting the 64 bits aligned one we will not have any trouble. Problem
-     * originally reported on SPARC 64.
-     */
     buf += sizeof(ompi_datatype_args_t);
     if( 0 != pArgs->ca ) {
         pArgs->a = (ptrdiff_t*)buf;
@@ -104,10 +119,18 @@ int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
         pArgs->d = (ompi_datatype_t**)buf;
         buf += pArgs->cd * sizeof(MPI_Datatype);
     }
-    if( 0 != pArgs->ci ) pArgs->i = (int*)buf;
+    if (0 != pArgs->cl ) {
+        pArgs->l = pl = (size_t*)buf;
+        buf += pArgs->cl * sizeof(size_t);
+    }
+    if( 0 != pArgs->ci ) {
+        pArgs->i = pi = (int*)buf;
+        buf += pArgs->ci * sizeof(int);
+    }
 
     pArgs->ref_count = 1;
-    pArgs->total_pack_size = (4 + ci) * sizeof(int) +
+    pArgs->total_pack_size = 5 * sizeof(size_t) + ci * sizeof(int) +
+                             cl * sizeof(size_t) +
                              cd * sizeof(MPI_Datatype) +
                              ca * sizeof(ptrdiff_t);
     switch(type) {
@@ -117,92 +140,120 @@ int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
         break;
 
     case MPI_COMBINER_CONTIGUOUS:
-        pArgs->i[0] = i[0][0];
+        copy_count_array(1, &pi, &pl, counts[0]);
         break;
 
     case MPI_COMBINER_VECTOR:
-        pArgs->i[0] = i[0][0];
-        pArgs->i[1] = i[1][0];
-        pArgs->i[2] = i[2][0];
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(1, &pi, &pl, counts[1]);
+        copy_count_array(1, &pi, &pl, counts[2]);
         break;
 
     case MPI_COMBINER_HVECTOR_INTEGER:
     case MPI_COMBINER_HVECTOR:
-        pArgs->i[0] = i[0][0];
-        pArgs->i[1] = i[1][0];
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(1, &pi, &pl, counts[1]);
+        if (cl > 0) {
+            // copy the stride
+            memcpy(pl, opal_count_array_ptr(counts[2]), sizeof(MPI_Count));
+            pl++;
+        }
         break;
 
-    case MPI_COMBINER_INDEXED:
-        pos = 1;
-        pArgs->i[0] = i[0][0];
-        memcpy( pArgs->i + pos, i[1], i[0][0] * sizeof(int) );
-        pos += i[0][0];
-        memcpy( pArgs->i + pos, i[2], i[0][0] * sizeof(int) );
+    case MPI_COMBINER_INDEXED: {
+        size_t count = opal_count_array_get(counts[0], 0);
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(count, &pi, &pl, counts[1]);
+        copy_count_array(count, &pi, &pl, counts[2]);
         break;
+    }
 
     case MPI_COMBINER_HINDEXED_INTEGER:
-    case MPI_COMBINER_HINDEXED:
-        pArgs->i[0] = i[0][0];
-        memcpy( pArgs->i + 1, i[1], i[0][0] * sizeof(int) );
+    case MPI_COMBINER_HINDEXED: {
+        size_t count = opal_count_array_get(counts[0], 0);
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(count, &pi, &pl, counts[1]);
+        if (cl > 0) {
+            // copy the displacements
+            memcpy(pl, opal_count_array_ptr(counts[2]), count * sizeof(MPI_Count));
+            pl += count;
+        }
         break;
+    }
 
-    case MPI_COMBINER_INDEXED_BLOCK:
-        pArgs->i[0] = i[0][0];
-        pArgs->i[1] = i[1][0];
-        memcpy( pArgs->i + 2, i[2], i[0][0] * sizeof(int) );
+    case MPI_COMBINER_INDEXED_BLOCK: {
+        size_t count = opal_count_array_get(counts[0], 0);
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(1, &pi, &pl, counts[1]);
+        copy_count_array(count, &pi, &pl, counts[2]);
         break;
+    }
 
     case MPI_COMBINER_STRUCT_INTEGER:
-    case MPI_COMBINER_STRUCT:
-        pArgs->i[0] = i[0][0];
-        memcpy( pArgs->i + 1, i[1], i[0][0] * sizeof(int) );
+    case MPI_COMBINER_STRUCT: {
+        size_t count = opal_count_array_get(counts[0], 0);
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(count, &pi, &pl, counts[1]);
+        if (cl > 0) {
+            // copy the displacements
+            memcpy(pl, opal_count_array_ptr(counts[2]), count * sizeof(MPI_Count));
+            pl += count;
+        }
         break;
+    }
 
-    case MPI_COMBINER_SUBARRAY:
-        pos = 1;
-        pArgs->i[0] = i[0][0];
-        memcpy( pArgs->i + pos, i[1], pArgs->i[0] * sizeof(int) );
-        pos += pArgs->i[0];
-        memcpy( pArgs->i + pos, i[2], pArgs->i[0] * sizeof(int) );
-        pos += pArgs->i[0];
-        memcpy( pArgs->i + pos, i[3], pArgs->i[0] * sizeof(int) );
-        pos += pArgs->i[0];
-        pArgs->i[pos] = i[4][0];
+    case MPI_COMBINER_SUBARRAY: {
+        size_t count = opal_count_array_get(counts[0], 0);
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(count, &pi, &pl, counts[1]);
+        copy_count_array(count, &pi, &pl, counts[2]);
+        copy_count_array(count, &pi, &pl, counts[3]);
+        copy_count_array(1, &pi, &pl, counts[4]);
         break;
+    }
 
-    case MPI_COMBINER_DARRAY:
-        pos = 3;
-        pArgs->i[0] = i[0][0];
-        pArgs->i[1] = i[1][0];
-        pArgs->i[2] = i[2][0];
-
-        memcpy( pArgs->i + pos, i[3], i[2][0] * sizeof(int) );
-        pos += i[2][0];
-        memcpy( pArgs->i + pos, i[4], i[2][0] * sizeof(int) );
-        pos += i[2][0];
-        memcpy( pArgs->i + pos, i[5], i[2][0] * sizeof(int) );
-        pos += i[2][0];
-        memcpy( pArgs->i + pos, i[6], i[2][0] * sizeof(int) );
-        pos += i[2][0];
-        pArgs->i[pos] = i[7][0];
+    case MPI_COMBINER_DARRAY: {
+        size_t ndim = opal_count_array_get(counts[2], 0);
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(1, &pi, &pl, counts[1]);
+        copy_count_array(1, &pi, &pl, counts[2]);
+        copy_count_array(ndim, &pi, &pl, counts[3]);
+        copy_count_array(ndim, &pi, &pl, counts[4]);
+        copy_count_array(ndim, &pi, &pl, counts[5]);
+        copy_count_array(ndim, &pi, &pl, counts[6]);
+        copy_count_array(1, &pi, &pl, counts[7]);
         break;
+    }
 
     case MPI_COMBINER_F90_REAL:
     case MPI_COMBINER_F90_COMPLEX:
-        pArgs->i[0] = i[0][0];
-        pArgs->i[1] = i[1][0];
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(1, &pi, &pl, counts[1]);
         break;
 
     case MPI_COMBINER_F90_INTEGER:
-        pArgs->i[0] = i[0][0];
+        copy_count_array(1, &pi, &pl, counts[0]);
         break;
 
     case MPI_COMBINER_RESIZED:
+        /* The large-count interface passes lb and extent as two MPI_Count
+         * values in counts[0]; the classic interface passes them through
+         * the displacement array instead (cl == 0 here, handled by the
+         * generic MPI_Aint copy below). */
+        if (cl > 0) {
+            copy_count_array(2, &pi, &pl, counts[0]);
+        }
         break;
 
     case MPI_COMBINER_HINDEXED_BLOCK:
-        pArgs->i[0] = i[0][0];
-        pArgs->i[1] = i[1][0];
+        copy_count_array(1, &pi, &pl, counts[0]);
+        copy_count_array(1, &pi, &pl, counts[1]);
+        if (cl > 0) {
+            // copy the displacements
+            size_t count = opal_count_array_get(counts[0], 0);
+            memcpy(pl, opal_count_array_ptr(counts[2]), count * sizeof(MPI_Count));
+            pl += count;
+        }
         break;
 
     default:
@@ -211,7 +262,7 @@ int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
 
     /* copy the array of MPI_Aint, aka ptrdiff_t */
     if( pArgs->a != NULL )
-        memcpy( pArgs->a, a, ca * sizeof(ptrdiff_t) );
+        memcpy( pArgs->a, ompi_disp_array_ptr(a), ca * sizeof(ptrdiff_t) );
 
     for( pos = 0; pos < cd; pos++ ) {
         pArgs->d[pos] = d[pos];
@@ -239,7 +290,7 @@ int32_t ompi_datatype_set_args( ompi_datatype_t* pData,
 
 int32_t ompi_datatype_print_args( const ompi_datatype_t* pData )
 {
-    int32_t i;
+    size_t i;
     ompi_datatype_args_t* pArgs = (ompi_datatype_args_t*)pData->args;
 
     if( ompi_datatype_is_predefined(pData) ) {
@@ -249,15 +300,22 @@ int32_t ompi_datatype_print_args( const ompi_datatype_t* pData )
 
     if( pArgs == NULL ) return MPI_ERR_INTERN;
 
-    printf( "type %d count ints %d count disp %d count datatype %d\n",
-            pArgs->create_type, pArgs->ci, pArgs->ca, pArgs->cd );
+    printf( "type %d count ints %zu count counts %zu count disp %zu count datatype %zu\n",
+            pArgs->create_type, pArgs->ci, pArgs->cl, pArgs->ca, pArgs->cd );
     if( pArgs->i != NULL ) {
-        printf( "ints:     " );
+        printf( "ints:     ");
         for( i = 0; i < pArgs->ci; i++ ) {
             printf( "%d ", pArgs->i[i] );
         }
         printf( "\n" );
     }
+    if( pArgs->l != NULL ) {
+        printf( "counts:     ");
+        for( i = 0; i < pArgs->cl; i++ ) {
+            printf( "%zu ", pArgs->l[i] );
+        }
+        printf( "\n" );
+    }
     if( pArgs->a != NULL ) {
         printf( "MPI_Aint: " );
         for( i = 0; i < pArgs->ca; i++ ) {
@@ -309,9 +367,10 @@ int32_t ompi_datatype_print_args( const ompi_datatype_t* pData )
 
 
 int32_t ompi_datatype_get_args( const ompi_datatype_t* pData, int32_t which,
-                                int32_t* ci, int32_t* i,
-                                int32_t* ca, ptrdiff_t* a,
-                                int32_t* cd, ompi_datatype_t** d, int32_t* type)
+                                size_t* ci, int* i,
+                                size_t* cl, MPI_Count* l,
+                                size_t* ca, ptrdiff_t* a,
+                                size_t* cd, ompi_datatype_t** d, int32_t* type)
 {
     ompi_datatype_args_t* pArgs = (ompi_datatype_args_t*)pData->args;
 
@@ -320,6 +379,7 @@ int32_t ompi_datatype_get_args( const ompi_datatype_t* pData, int32_t which,
             switch(which){
             case 0:
                 *ci = 0;
+                *cl = 0;
                 *ca = 0;
                 *cd = 0;
                 *type = MPI_COMBINER_NAMED;
@@ -335,17 +395,21 @@ int32_t ompi_datatype_get_args( const ompi_datatype_t* pData, int32_t which,
     switch(which){
     case 0:     /* GET THE LENGTHS */
         *ci = pArgs->ci;
+        *cl = pArgs->cl;
         *ca = pArgs->ca;
         *cd = pArgs->cd;
         *type = pArgs->create_type;
         break;
     case 1:     /* GET THE ARGUMENTS */
-        if(*ci < pArgs->ci || *ca < pArgs->ca || *cd < pArgs->cd) {
+        if(*ci < pArgs->ci || *cl < pArgs->cl || *ca < pArgs->ca || *cd < pArgs->cd) {
             return MPI_ERR_ARG;
         }
         if( (NULL != i) && (NULL != pArgs->i) ) {
             memcpy( i, pArgs->i, pArgs->ci * sizeof(int) );
         }
+        if( (NULL != l) && (NULL != pArgs->l) ) {
+            memcpy( l, pArgs->l, pArgs->cl * sizeof(size_t) );
+        }
         if( (NULL != a) && (NULL != pArgs->a) ) {
             memcpy( a, pArgs->a, pArgs->ca * sizeof(ptrdiff_t) );
         }
@@ -384,7 +448,7 @@ int32_t ompi_datatype_copy_args( const ompi_datatype_t* source_data,
  */
 int32_t ompi_datatype_release_args( ompi_datatype_t* pData )
 {
-    int i;
+    size_t i;
     ompi_datatype_args_t* pArgs = (ompi_datatype_args_t*)pData->args;
 
     assert( 0 < pArgs->ref_count );
@@ -409,13 +473,16 @@ int32_t ompi_datatype_release_args( ompi_datatype_t* pData )
 static inline int __ompi_datatype_pack_description( ompi_datatype_t* datatype,
                                                     void** packed_buffer, int* next_index )
 {
-    int i, *position = (int*)*packed_buffer;
+    size_t i;
+    int *iposition = NULL;
     ompi_datatype_args_t* args = (ompi_datatype_args_t*)datatype->args;
     char* next_packed = (char*)*packed_buffer;
 
+    iposition = (int*)next_packed;
+
     if( ompi_datatype_is_predefined(datatype) ) {
-        position[0] = MPI_COMBINER_NAMED;
-        position[1] = datatype->id;   /* On the OMPI - layer, copy the ompi_datatype.id */
+        iposition[0] = MPI_COMBINER_NAMED;
+        iposition[1] = datatype->id;   /* On the OMPI - layer, copy the ompi_datatype.id */
         next_packed += (2 * sizeof(int));
         *packed_buffer = next_packed;
         return OMPI_SUCCESS;
@@ -427,38 +494,43 @@ static inline int __ompi_datatype_pack_description( ompi_datatype_t* datatype,
                                                 packed_buffer,
                                                 next_index );
     }
-    position[0] = args->create_type;
-    position[1] = args->ci;
-    position[2] = args->ca;
-    position[3] = args->cd;
-    next_packed += (4 * sizeof(int));
-    /* Spoiler: We will access the data in this storage structure, and thus we
-     * need to align it to the expected boundaries (special thanks to Sparc64).
-     * The simplest way is to ensure that prior to each type that must be 64
-     * bits aligned, we have a pointer that is 64 bits aligned. That will minimize
-     * the memory requirements in all cases where no displacements are stored.
-     */
+    iposition[0] = args->create_type;
+    next_packed += sizeof(int);
+    /* align pointer to 64 bits */
+    OMPI_DATATYPE_ALIGN_PTR(next_packed, char*);
+    size_t *cposition = ((size_t*)next_packed);
+    cposition[0] = args->ci;
+    cposition[1] = args->cl;
+    cposition[2] = args->ca;
+    cposition[3] = args->cd;
+    next_packed += (4 * sizeof(size_t));
     if( 0 < args->ca ) {
-        /* description of the displacements must be 64 bits aligned */
-        OMPI_DATATYPE_ALIGN_PTR(next_packed, char*);
-
         memcpy( next_packed, args->a, sizeof(ptrdiff_t) * args->ca );
         next_packed += sizeof(ptrdiff_t) * args->ca;
     }
-    position = (int*)next_packed;
+    if ( 0 < args->cl ) {
+        memcpy( next_packed, args->l, sizeof(size_t) * args->cl );
+        next_packed += sizeof(size_t) * args->cl;
+    }
+    /* advance int pointer */
+    iposition = (int*)next_packed;
+
+    /* skip the datatypes */
     next_packed += sizeof(int) * args->cd;
 
-    /* copy the array of counts (32 bits aligned) */
-    memcpy( next_packed, args->i, sizeof(int) * args->ci );
-    next_packed += args->ci * sizeof(int);
+    /* copy the array of 32bit counts at the end */
+    if( 0 < args->ci ) {
+        memcpy( next_packed, args->i, sizeof(int) * args->ci );
+        next_packed += args->ci * sizeof(int);
+    }
 
     /* copy the rest of the data */
     for( i = 0; i < args->cd; i++ ) {
         ompi_datatype_t* temp_data = args->d[i];
         if( ompi_datatype_is_predefined(temp_data) ) {
-            position[i] = temp_data->id;  /* On the OMPI - layer, copy the ompi_datatype.id */
+            iposition[i] = temp_data->id;  /* On the OMPI - layer, copy the ompi_datatype.id */
         } else {
-            position[i] = *next_index;
+            iposition[i] = *next_index;
             (*next_index)++;
             __ompi_datatype_pack_description( temp_data,
                                               (void**)&next_packed,
@@ -548,13 +620,16 @@ size_t ompi_datatype_pack_description_length( ompi_datatype_t* datatype )
 static ompi_datatype_t* __ompi_datatype_create_from_packed_description( void** packed_buffer,
                                                                         const struct ompi_proc_t* remote_processor )
 {
-    int* position;
+    int* iposition;
+    size_t *cposition;
     ompi_datatype_t* datatype = NULL;
     ompi_datatype_t** array_of_datatype;
     ptrdiff_t* array_of_disp;
-    int* array_of_length;
-    int number_of_length, number_of_disp, number_of_datatype, data_id;
-    int create_type, i;
+    int* array_of_ints;
+    size_t *array_of_counts = NULL;
+    size_t number_of_ints, number_of_counts, number_of_disp, number_of_datatype, data_id;
+    int create_type;
+    size_t i;
     char* next_buffer;
 
 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
@@ -567,9 +642,14 @@ static ompi_datatype_t* __ompi_datatype_create_from_packed_description( void** p
 #endif
 
     next_buffer = (char*)*packed_buffer;
-    position = (int*)next_buffer;
-
-    create_type = position[0];
+    cposition = (size_t*)next_buffer;
+    iposition = (int*)next_buffer;
+
+    create_type = (int)iposition[0];
+    next_buffer += sizeof(int);
+    /* align pointer to 64 bits */
+    OMPI_DATATYPE_ALIGN_PTR(next_buffer, char*);
+    cposition = (size_t*)next_buffer;
 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
     if (need_swap) {
         create_type = opal_swap_bytes4(create_type);
@@ -577,48 +657,50 @@ static ompi_datatype_t* __ompi_datatype_create_from_packed_description( void** p
 #endif
     if( MPI_COMBINER_NAMED == create_type ) {
         /* there we have a simple predefined datatype */
-        data_id = position[1];
+        data_id = iposition[1];
 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
         if (need_swap) {
             data_id = opal_swap_bytes4(data_id);
         }
 #endif
         assert( data_id < OMPI_DATATYPE_MAX_PREDEFINED );
-        *packed_buffer = position + 2;
+        *packed_buffer = iposition + 2;
         return (ompi_datatype_t*)ompi_datatype_basicDatatypes[data_id];
     }
 
-    number_of_length   = position[1];
-    number_of_disp     = position[2];
-    number_of_datatype = position[3];
+    number_of_ints     = cposition[0];
+    number_of_counts   = cposition[1];
+    number_of_disp     = cposition[2];
+    number_of_datatype = cposition[3];
 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
     if (need_swap) {
-        number_of_length   = opal_swap_bytes4(number_of_length);
-        number_of_disp     = opal_swap_bytes4(number_of_disp);
-        number_of_datatype = opal_swap_bytes4(number_of_datatype);
+        number_of_ints     = opal_swap_bytes8(number_of_ints);
+        number_of_counts   = opal_swap_bytes8(number_of_counts);
+        number_of_disp     = opal_swap_bytes8(number_of_disp);
+        number_of_datatype = opal_swap_bytes8(number_of_datatype);
     }
 #endif
     array_of_datatype = (ompi_datatype_t**)malloc( sizeof(ompi_datatype_t*) *
                                                    number_of_datatype );
-    next_buffer += (4 * sizeof(int));  /* move after the header */
-
-    /* description of the displacements (if ANY !)  should always be aligned
-       on MPI_Aint, aka ptrdiff_t */
-    if (number_of_disp > 0) {
-        OMPI_DATATYPE_ALIGN_PTR(next_buffer, char*);
-    }
-
+    next_buffer += (4 * sizeof(size_t));  /* move after the header */
+    /* the array of displacements */
     array_of_disp   = (ptrdiff_t*)next_buffer;
     next_buffer    += number_of_disp * sizeof(ptrdiff_t);
+    if (number_of_counts > 0) {
+        array_of_counts = (size_t*)next_buffer;
+        next_buffer    += number_of_counts * sizeof(size_t);
+    }
     /* the other datatypes */
-    position        = (int*)next_buffer;
+    iposition        = (int*)next_buffer;
     next_buffer    += number_of_datatype * sizeof(int);
     /* the array of lengths (32 bits aligned) */
-    array_of_length = (int*)next_buffer;
-    next_buffer    += (number_of_length * sizeof(int));
+    if (number_of_ints > 0) {
+        array_of_ints = (int*)next_buffer;
+        next_buffer += number_of_ints * sizeof(int);
+    }
 
     for( i = 0; i < number_of_datatype; i++ ) {
-        data_id = position[i];
+        data_id = iposition[i];
 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
         if (need_swap) {
             data_id = opal_swap_bytes4(data_id);
@@ -644,8 +726,11 @@ static ompi_datatype_t* __ompi_datatype_create_from_packed_description( void** p
 
 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
     if (need_swap) {
-        for (i = 0 ; i < number_of_length ; ++i) {
-            array_of_length[i] = opal_swap_bytes4(array_of_length[i]);
+        for (i = 0 ; i < number_of_ints ; ++i) {
+            array_of_ints[i] = opal_swap_bytes4(array_of_ints[i]);
+        }
+        for (i = 0 ; i < number_of_counts ; ++i) {
+            array_of_counts[i] = opal_swap_bytes8(array_of_counts[i]);
         }
         for (i = 0 ; i < number_of_disp ; ++i) {
 #if SIZEOF_PTRDIFF_T == 4
@@ -658,7 +743,7 @@ static ompi_datatype_t* __ompi_datatype_create_from_packed_description( void** p
         }
     }
 #endif
-    datatype = __ompi_datatype_create_from_args( array_of_length, array_of_disp,
+    datatype = __ompi_datatype_create_from_args( array_of_ints, array_of_counts, array_of_disp,
                                                  array_of_datatype, create_type );
     *packed_buffer = next_buffer;
  cleanup_and_exit:
@@ -671,11 +756,14 @@ static ompi_datatype_t* __ompi_datatype_create_from_packed_description( void** p
     return datatype;
 }
 
-static ompi_datatype_t* __ompi_datatype_create_from_args( int32_t* i, MPI_Aint* a,
+static ompi_datatype_t* __ompi_datatype_create_from_args( const int* i, const size_t *l, const ptrdiff_t* a,
                                                           ompi_datatype_t** d, int32_t type )
 {
+    size_t count, ci = 0, cl = 0;
     ompi_datatype_t* datatype = NULL;
 
+    ompi_disp_array_t disp_array = OMPI_DISP_ARRAY_CREATE(a);
+
     switch(type){
         /******************************************************************/
     case MPI_COMBINER_DUP:
@@ -684,81 +772,243 @@ static ompi_datatype_t* __ompi_datatype_create_from_args( int32_t* i, MPI_Aint*
         assert(0);  /* shouldn't happen */
         break;
         /******************************************************************/
-    case MPI_COMBINER_CONTIGUOUS:
-        ompi_datatype_create_contiguous( i[0], d[0], &datatype );
-        ompi_datatype_set_args( datatype, 1, (const int **) &i, 0, NULL, 1, d, MPI_COMBINER_CONTIGUOUS );
+    case MPI_COMBINER_CONTIGUOUS: {
+        ompi_count_array_t a_i[1];
+        if (l == NULL) {
+            count = i[0];
+            a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+            ci = 1;
+        } else { // large count variant
+            count = l[0];
+            a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+            cl = 1;
+        }
+        ompi_datatype_create_contiguous( count, d[0], &datatype );
+        ompi_datatype_set_args( datatype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, d, MPI_COMBINER_CONTIGUOUS );
         break;
+    }
         /******************************************************************/
-    case MPI_COMBINER_VECTOR:
-        ompi_datatype_create_vector( i[0], i[1], i[2], d[0], &datatype );
-        {
-            const int* a_i[3] = {&i[0], &i[1], &i[2]};
-            ompi_datatype_set_args( datatype, 3, a_i, 0, NULL, 1, d, MPI_COMBINER_VECTOR );
+    case MPI_COMBINER_VECTOR: {
+        size_t blocklength, stride;
+        opal_count_array_t a_i[3];
+        if (l == NULL) {
+            count      = i[0];
+            blocklength= i[1];
+            stride     = i[2];
+            a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+            a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+            a_i[2] = OMPI_COUNT_ARRAY_CREATE(i + 2);
+            ci = 3;
+        } else { // large count variant
+            count      = l[0];
+            blocklength= l[1];
+            stride     = l[2];
+            a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+            a_i[1] = OMPI_COUNT_ARRAY_CREATE(l + 1);
+            a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + 2);
+            cl = 3;
         }
+        ompi_datatype_create_vector( count, blocklength, stride, d[0], &datatype );
+        ompi_datatype_set_args( datatype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, d, MPI_COMBINER_VECTOR );
         break;
+    }
         /******************************************************************/
     case MPI_COMBINER_HVECTOR_INTEGER:
     case MPI_COMBINER_HVECTOR:
-        ompi_datatype_create_hvector( i[0], i[1], a[0], d[0], &datatype );
         {
-            const int* a_i[2] = {&i[0], &i[1]};
-            ompi_datatype_set_args( datatype, 2, a_i, 1, a, 1, d, MPI_COMBINER_HVECTOR );
+            size_t blocklength;
+            ptrdiff_t stride;
+            opal_count_array_t a_i[3];
+            size_t ca = 0;
+            if (l == NULL) {
+                count          = i[0];
+                blocklength    = i[1];
+                stride         = a[0];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+                ci = 2;
+                ca = 1; // stride stored in disp_array
+            } else { // large count variant
+                count          = l[0];
+                blocklength    = l[1];
+                stride         = l[2];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(l + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + 2);
+                cl = 3;
+            }
+            ompi_datatype_create_hvector( count, blocklength, stride, d[0], &datatype );
+            ompi_datatype_set_args( datatype, ci, cl, a_i, ca, disp_array, 1, d, MPI_COMBINER_HVECTOR );
         }
         break;
         /******************************************************************/
     case MPI_COMBINER_INDEXED:  /* TO CHECK */
-        ompi_datatype_create_indexed( i[0], &(i[1]), &(i[1+i[0]]), d[0], &datatype );
         {
-            const int* a_i[3] = {&i[0], &i[1], &(i[1+i[0]])};
-            ompi_datatype_set_args( datatype, 2 * i[0] + 1, a_i, 0, NULL, 1, d, MPI_COMBINER_INDEXED );
+            opal_count_array_t a_i[3];
+            if (l == NULL) {
+                count = i[0];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(i + 1 + count);
+                ci = 2 * count + 1;
+            } else {
+                count = l[0];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(l + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + 1 + count);
+                cl = 2 * count + 1;
+            }
+            ompi_datatype_create_indexed( count, a_i[1], a_i[2], d[0], &datatype );
+            ompi_datatype_set_args( datatype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, d, MPI_COMBINER_INDEXED );
         }
         break;
         /******************************************************************/
     case MPI_COMBINER_HINDEXED_INTEGER:
     case MPI_COMBINER_HINDEXED:
-        ompi_datatype_create_hindexed( i[0], &(i[1]), a, d[0], &datatype );
         {
-            const int* a_i[2] = {&i[0], &i[1]};
-            ompi_datatype_set_args( datatype, i[0] + 1, a_i, i[0], a, 1, d, MPI_COMBINER_HINDEXED );
+            opal_count_array_t a_i[3];
+            size_t ca = 0;
+            opal_disp_array_t disp_args; // for set_args
+            opal_disp_array_t displacements; // for create_hindexed
+            if (l == NULL) {
+                count = i[0];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+                ci = count+1;
+                ca = count;
+                disp_args = disp_array;
+                displacements = disp_array;
+            } else {
+                count = l[0];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(l + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + 1 + count); // displacements are MPI_Count
+                cl = 2*count+1;
+                disp_args = OMPI_DISP_ARRAY_NULL;
+                displacements = OMPI_DISP_ARRAY_CREATE(l + 1 + count);
+            }
+            ompi_datatype_create_hindexed( count, a_i[1], displacements, d[0], &datatype );
+            ompi_datatype_set_args( datatype, ci, cl, a_i, ca, disp_args, 1, d, MPI_COMBINER_HINDEXED );
         }
         break;
         /******************************************************************/
     case MPI_COMBINER_INDEXED_BLOCK:
-        ompi_datatype_create_indexed_block( i[0], i[1], &(i[2]), d[0], &datatype );
         {
-            const int* a_i[3] = {&i[0], &i[1], &i[2]};
-            ompi_datatype_set_args( datatype, i[0] + 2, a_i, 0, NULL, 1, d, MPI_COMBINER_INDEXED_BLOCK );
+            opal_count_array_t a_i[3];
+            size_t blocklength;
+            if (l == NULL) {
+                count        = i[0];
+                blocklength  = i[1];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(i + 2);
+                ci = 2 + count;
+            } else {
+                count        = l[0];
+                blocklength  = l[1];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(l + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + 2);
+                cl = 2 + count;
+            }
+            ompi_datatype_create_indexed_block( count, blocklength, a_i[2], d[0], &datatype );
+            ompi_datatype_set_args( datatype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, d, MPI_COMBINER_INDEXED_BLOCK );
         }
         break;
         /******************************************************************/
     case MPI_COMBINER_STRUCT_INTEGER:
     case MPI_COMBINER_STRUCT:
-        ompi_datatype_create_struct( i[0], &(i[1]), a, d, &datatype );
         {
-            const int* a_i[2] = {&i[0], &i[1]};
-            ompi_datatype_set_args( datatype, i[0] + 1, a_i, i[0], a, i[0], d, MPI_COMBINER_STRUCT );
+            opal_count_array_t a_i[3];
+            opal_disp_array_t displacements;
+            opal_disp_array_t disp_args;
+            size_t ca = 0;
+            if (l == NULL) {
+                count = i[0];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+                ci = 2 * count + 1;
+                displacements = disp_array;
+                disp_args = disp_array;
+                ca = count;
+            } else {
+                count = l[0];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(l + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + 1 + count);
+                displacements = OMPI_DISP_ARRAY_CREATE(l + 1 + count);
+                disp_args = OMPI_DISP_ARRAY_NULL;
+                cl = 2*count + 1;
+            }
+            ompi_datatype_create_struct( count, a_i[1], displacements, d, &datatype );
+            ompi_datatype_set_args( datatype, ci, cl, a_i, ca, disp_args, count, d, MPI_COMBINER_STRUCT );
         }
         break;
         /******************************************************************/
     case MPI_COMBINER_SUBARRAY:
-        ompi_datatype_create_subarray( i[0], &i[1 + 0 * i[0]], &i[1 + 1 * i[0]],
-                                       &i[1 + 2 * i[0]], i[1 + 3 * i[0]],
-                                       d[0], &datatype );
         {
-            const int* a_i[5] = {&i[0], &i[1 + 0 * i[0]], &i[1 + 1 * i[0]], &i[1 + 2 * i[0]], &i[1 + 3 * i[0]]};
-            ompi_datatype_set_args( datatype, 3 * i[0] + 2, a_i, 0, NULL, 1, d, MPI_COMBINER_SUBARRAY);
+            count = i[0]; // first element in int array
+            int order;
+            opal_count_array_t a_i[5];
+            if (l == NULL) {
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(i + 1 + count);
+                a_i[3] = OMPI_COUNT_ARRAY_CREATE(i + 1 + 2*count);
+                a_i[4] = OMPI_COUNT_ARRAY_CREATE(i + 1 + 3*count);
+                order = i[3*count+1]; // last element in int array
+                ci = 3 * count + 2;
+            } else {
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);            // ndim
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(l);            // sizes
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + count);    // subsizes
+                a_i[3] = OMPI_COUNT_ARRAY_CREATE(l + 2*count);  // starts
+                a_i[4] = OMPI_COUNT_ARRAY_CREATE(i+1);          // order
+                order = i[1]; // second (and last) element in int array
+                cl = 3 * count;
+                ci = 2;
+            }
+            ompi_datatype_create_subarray( count, a_i[1], a_i[2], a_i[3], order, d[0], &datatype );
+            ompi_datatype_set_args( datatype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, d, MPI_COMBINER_SUBARRAY );
         }
         break;
         /******************************************************************/
     case MPI_COMBINER_DARRAY:
-        ompi_datatype_create_darray( i[0] /* size */, i[1] /* rank */, i[2] /* ndims */,
-                                     &i[3 + 0 * i[2]], &i[3 + 1 * i[2]],
-                                     &i[3 + 2 * i[2]], &i[3 + 3 * i[2]],
-                                     i[3 + 4 * i[2]], d[0], &datatype );
         {
-            const int* a_i[8] = {&i[0], &i[1], &i[2], &i[3 + 0 * i[2]], &i[3 + 1 * i[2]], &i[3 + 2 * i[2]],
-                                 &i[3 + 3 * i[2]], &i[3 + 4 * i[2]]};
-            ompi_datatype_set_args( datatype, 4 * i[2] + 4, a_i, 0, NULL, 1, d, MPI_COMBINER_DARRAY);
+            int size  = i[0];
+            int rank  = i[1];
+            int ndims = i[2];
+            ompi_count_array_t gsize_array;
+            const int *distrib_array;
+            const int *darg_array;
+            const int *psize_array;
+            int order;
+            if (l == NULL) {
+                gsize_array   = OMPI_COUNT_ARRAY_CREATE(i + 3);
+                distrib_array = &i[3 + 1*ndims];
+                darg_array    = &i[3 + 2*ndims];
+                psize_array   = &i[3 + 3*ndims];
+                order         =  i[3 + 4*ndims];
+                ci = 4 + 4 * ndims;
+            } else {
+                gsize_array   = OMPI_COUNT_ARRAY_CREATE(l);
+                distrib_array = &i[3 + 0*ndims];
+                darg_array    = &i[3 + 1*ndims];
+                psize_array   = &i[3 + 2*ndims];
+                order         =  i[3 + 3*ndims];
+                ci = 4 + 3 * ndims;
+                cl = ndims;
+            }
+            opal_count_array_t a_i[8] = {OMPI_COUNT_ARRAY_CREATE(&size),
+                                         OMPI_COUNT_ARRAY_CREATE(&rank),
+                                         OMPI_COUNT_ARRAY_CREATE(&ndims),
+                                         gsize_array,
+                                         OMPI_COUNT_ARRAY_CREATE(distrib_array),
+                                         OMPI_COUNT_ARRAY_CREATE(darg_array),
+                                         OMPI_COUNT_ARRAY_CREATE(psize_array),
+                                         OMPI_COUNT_ARRAY_CREATE(&order)};
+            ompi_datatype_create_darray( size, rank, ndims, gsize_array, distrib_array, darg_array, psize_array, order, d[0], &datatype );
+            ompi_datatype_set_args( datatype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, d, MPI_COMBINER_DARRAY);
         }
         break;
         /******************************************************************/
@@ -774,15 +1024,53 @@ static ompi_datatype_t* __ompi_datatype_create_from_args( int32_t* i, MPI_Aint*
         break;
         /******************************************************************/
     case MPI_COMBINER_RESIZED:
-        ompi_datatype_create_resized(d[0], a[0], a[1], &datatype);
-        ompi_datatype_set_args( datatype, 0, NULL, 2, a, 1, d, MPI_COMBINER_RESIZED );
+        if (NULL == l) {
+            /* classic: lb/extent were stored as MPI_Aint displacements */
+            ompi_datatype_create_resized(d[0], a[0], a[1], &datatype);
+            ompi_datatype_set_args( datatype, 0, 0, NULL, 2, disp_array, 1, d, MPI_COMBINER_RESIZED );
+        } else {
+            /* large count: lb/extent were stored as MPI_Count large counts.
+             * lb may be negative; the size_t -> ptrdiff_t cast restores the
+             * signed value via a two's-complement round-trip. */
+            ompi_count_array_t a_i[1] = {OMPI_COUNT_ARRAY_CREATE(l)};
+            ompi_datatype_create_resized(d[0], (ptrdiff_t) l[0], (ptrdiff_t) l[1], &datatype);
+            ompi_datatype_set_args( datatype, 0, 2, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, d, MPI_COMBINER_RESIZED );
+        }
         break;
         /******************************************************************/
     case MPI_COMBINER_HINDEXED_BLOCK:
-        ompi_datatype_create_hindexed_block( i[0], i[1], a, d[0], &datatype );
         {
-            const int* a_i[2] = {&i[0], &i[1]};
-            ompi_datatype_set_args( datatype, 2, a_i, i[0], a, 1, d, MPI_COMBINER_HINDEXED_BLOCK );
+            size_t bLength = 0;
+            size_t ca;
+            opal_disp_array_t displacements; // for create_hindexed_block
+            opal_disp_array_t disp_args; // for set_args
+            opal_count_array_t a_i[3];
+            if (l == NULL) {
+                count = i[0];
+                bLength = i[1];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(i);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(i + 1);
+                ci = 2;
+                displacements = disp_array;
+                disp_args = disp_array;
+                ca = count; // displacements stored in disp_array
+            } else {
+                count = l[0];
+                bLength = l[1];
+                a_i[0] = OMPI_COUNT_ARRAY_CREATE(l);
+                a_i[1] = OMPI_COUNT_ARRAY_CREATE(l + 1);
+                a_i[2] = OMPI_COUNT_ARRAY_CREATE(l + 2);
+                /* count + blocklength + count displacements; hardcoding 3
+                 * here (the count == 1 case) under-allocates the large-count
+                 * array in set_args and corrupts the envelope. */
+                cl = 2 + count;
+                displacements = OMPI_DISP_ARRAY_CREATE(l + 2); // displacements are MPI_Count
+                disp_args = OMPI_DISP_ARRAY_NULL;
+                ca = 0;
+            }
+            ompi_datatype_create_hindexed_block( count, bLength, displacements, d[0], &datatype );
+
+            ompi_datatype_set_args( datatype, ci, cl, a_i, ca, disp_args, 1, d, MPI_COMBINER_HINDEXED_BLOCK );
         }
         break;
         /******************************************************************/
@@ -793,6 +1081,15 @@ static ompi_datatype_t* __ompi_datatype_create_from_args( int32_t* i, MPI_Aint*
     return datatype;
 }
 
+/*
+ * Note: *packed_buffer must be at least word-size (sizeof(ptrdiff_t))
+ * aligned.  The description interleaves 32-bit ints with word-size values
+ * and the unpack code realigns the running pointer to word size before each
+ * word-size access (see OMPI_DATATYPE_ALIGN_PTR); that realignment is
+ * relative to the buffer base, so the base must itself be word aligned for
+ * the reads to land on the same offsets the packer wrote.  Buffers produced
+ * by ompi_datatype_get_pack_description() (malloc'd) satisfy this.
+ */
 ompi_datatype_t* ompi_datatype_create_from_packed_description( void** packed_buffer,
                                                                struct ompi_proc_t* remote_processor )
 {
@@ -816,7 +1113,7 @@ ompi_datatype_t* ompi_datatype_get_single_predefined_type_from_args( ompi_dataty
 {
     ompi_datatype_t *predef = NULL, *current_type, *current_predef;
     ompi_datatype_args_t* args = (ompi_datatype_args_t*)type->args;
-    int i;
+    size_t i;
 
     if( ompi_datatype_is_predefined(type) )
         return type;
diff --git a/ompi/datatype/ompi_datatype_create.c b/ompi/datatype/ompi_datatype_create.c
index 76e87a0593f..64f2740270e 100644
--- a/ompi/datatype/ompi_datatype_create.c
+++ b/ompi/datatype/ompi_datatype_create.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2018      Amazon.com, Inc. or its affiliates.  All Rights reserved.
  * Copyright (c) 2025      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -71,7 +72,7 @@ static void __ompi_datatype_release(ompi_datatype_t * datatype)
 
 OBJ_CLASS_INSTANCE(ompi_datatype_t, opal_datatype_t, __ompi_datatype_allocate, __ompi_datatype_release);
 
-ompi_datatype_t * ompi_datatype_create( int32_t expectedSize )
+ompi_datatype_t * ompi_datatype_create( size_t expectedSize )
 {
     int ret;
     ompi_datatype_t * datatype = (ompi_datatype_t*)OBJ_NEW(ompi_datatype_t);
diff --git a/ompi/datatype/ompi_datatype_create_contiguous.c b/ompi/datatype/ompi_datatype_create_contiguous.c
index 6a287caa41c..e0a7503713e 100644
--- a/ompi/datatype/ompi_datatype_create_contiguous.c
+++ b/ompi/datatype/ompi_datatype_create_contiguous.c
@@ -12,6 +12,7 @@
  *                         All rights reserved.
  * Copyright (c) 2009      Sun Microsystems, Inc. All rights reserved.
  * Copyright (c) 2009      Oak Ridge National Labs.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -24,7 +25,7 @@
 #include "ompi/datatype/ompi_datatype_internal.h"
 #include "mpi.h"
 
-int32_t ompi_datatype_create_contiguous( int count, const ompi_datatype_t* oldType,
+int32_t ompi_datatype_create_contiguous( size_t count, const ompi_datatype_t* oldType,
                                          ompi_datatype_t** newType )
 {
     ompi_datatype_t* pdt;
diff --git a/ompi/datatype/ompi_datatype_create_darray.c b/ompi/datatype/ompi_datatype_create_darray.c
index e0292755c4b..ddc6ad1e1e8 100644
--- a/ompi/datatype/ompi_datatype_create_darray.c
+++ b/ompi/datatype/ompi_datatype_create_darray.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2016      Los Alamos National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2017      IBM Corporation. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -30,18 +31,24 @@
 #include "ompi/datatype/ompi_datatype.h"
 
 static int
-block(const int *gsize_array, int dim, int ndims, int nprocs,
+block(ompi_count_array_t gsize_array, int dim, int ndims, int nprocs,
       int rank, int darg, int order, ptrdiff_t orig_extent,
       ompi_datatype_t *type_old, ompi_datatype_t **type_new,
       ptrdiff_t *st_offset)
 {
-    int blksize, global_size, mysize, i, j, rc, start_loop, step;
+    int i, rc, start_loop, step;
+    /* global_size and the derived block/local sizes can exceed INT_MAX for
+     * big-count gsizes, so they must be 64 bit (signed: mysize/j can go
+     * negative before clamping). */
+    ptrdiff_t blksize, global_size, mysize, j;
     ptrdiff_t stride, disps[2];
 
-    global_size = gsize_array[dim];
+    global_size = ompi_count_array_get(gsize_array, dim);
 
     if (darg == MPI_DISTRIBUTE_DFLT_DARG)
-        blksize = (global_size + nprocs - 1) / nprocs;
+        /* ceil(global_size/nprocs) without the "+ nprocs - 1" addition, which
+         * would overflow ptrdiff_t for a global_size near PTRDIFF_MAX. */
+        blksize = global_size / nprocs + (0 != global_size % nprocs);
     else {
         blksize = darg;
     }
@@ -58,13 +65,13 @@ block(const int *gsize_array, int dim, int ndims, int nprocs,
 
     stride = orig_extent;
     if (dim == start_loop) {
-        rc = ompi_datatype_create_contiguous(mysize, type_old, type_new);
+        rc = ompi_datatype_create_contiguous((size_t) mysize, type_old, type_new);
         if (OMPI_SUCCESS != rc) return rc;
     } else {
         for (i = start_loop ; i != dim ; i += step) {
-            stride *= gsize_array[i];
+            stride *= ompi_count_array_get(gsize_array, i);
         }
-        rc = ompi_datatype_create_hvector(mysize, 1, stride, type_old, type_new);
+        rc = ompi_datatype_create_hvector((size_t) mysize, 1, stride, type_old, type_new);
         if (OMPI_SUCCESS != rc) return rc;
     }
 
@@ -76,11 +83,11 @@ block(const int *gsize_array, int dim, int ndims, int nprocs,
     disps[0] = 0;         disps[1] = orig_extent;
     if (order == MPI_ORDER_FORTRAN) {
         for(i=0; i<=dim; i++) {
-            disps[1] *= gsize_array[i];
+            disps[1] *= ompi_count_array_get(gsize_array, i);
         }
     } else {
         for(i=ndims-1; i>=dim; i--) {
-            disps[1] *= gsize_array[i];
+            disps[1] *= ompi_count_array_get(gsize_array, i);
         }
     }
     rc = opal_datatype_resize( &(*type_new)->super, disps[0], disps[1] );
@@ -91,12 +98,16 @@ block(const int *gsize_array, int dim, int ndims, int nprocs,
 
 
 static int
-cyclic(const int *gsize_array, int dim, int ndims, int nprocs,
+cyclic(ompi_count_array_t gsize_array, int dim, int ndims, int nprocs,
        int rank, int darg, int order, ptrdiff_t orig_extent,
        ompi_datatype_t* type_old, ompi_datatype_t **type_new,
        ptrdiff_t *st_offset)
 {
-    int blksize, i, blklens[2], st_index, end_index, local_size, rem, count, rc;
+    int blksize, i, blklens[2], rc;
+    /* The global index range and local element count can exceed INT_MAX
+     * for big-count gsizes (blksize stays int -- it is the int-typed
+     * distribution argument). */
+    ptrdiff_t st_index, end_index, local_size, rem, count;
     ptrdiff_t stride, disps[2];
     ompi_datatype_t *type_tmp, *types[2];
 
@@ -106,32 +117,35 @@ cyclic(const int *gsize_array, int dim, int ndims, int nprocs,
         blksize = darg;
     }
 
-    st_index = rank * blksize;
-    end_index = gsize_array[dim] - 1;
+    /* blksize stays int (it is the int distribution argument), but force the
+     * index/stride products to 64 bits so they cannot overflow before being
+     * stored in the (widened) ptrdiff_t locals. */
+    st_index = (ptrdiff_t) rank * blksize;
+    end_index = ompi_count_array_get(gsize_array, dim) - 1;
 
     if (end_index < st_index) {
         local_size = 0;
     } else {
-        local_size = ((end_index - st_index + 1)/(nprocs*blksize))*blksize;
-        rem = (end_index - st_index + 1) % (nprocs*blksize);
+        local_size = ((end_index - st_index + 1)/((ptrdiff_t) nprocs*blksize))*blksize;
+        rem = (end_index - st_index + 1) % ((ptrdiff_t) nprocs*blksize);
         local_size += rem < blksize ? rem : blksize;
     }
 
     count = local_size / blksize;
     rem = local_size % blksize;
 
-    stride = nprocs*blksize*orig_extent;
+    stride = (ptrdiff_t) nprocs*blksize*orig_extent;
     if (order == MPI_ORDER_FORTRAN) {
         for (i=0; i<dim; i++) {
-            stride *= gsize_array[i];
+            stride *= ompi_count_array_get(gsize_array, i);
         }
     } else {
         for (i=ndims-1; i>dim; i--) {
-            stride *= gsize_array[i];
+            stride *= ompi_count_array_get(gsize_array, i);
         }
     }
 
-    rc = ompi_datatype_create_hvector(count, blksize, stride, type_old, type_new);
+    rc = ompi_datatype_create_hvector((size_t) count, blksize, stride, type_old, type_new);
     if (OMPI_SUCCESS != rc) return rc;
 
     if (rem) {
@@ -140,9 +154,9 @@ cyclic(const int *gsize_array, int dim, int ndims, int nprocs,
 
         types  [0] = *type_new; types  [1] = type_old;
         disps  [0] = 0;         disps  [1] = count*stride;
-        blklens[0] = 1;         blklens[1] = rem;
+        blklens[0] = 1;         blklens[1] = (int) rem; /* rem < blksize (int) */
 
-        rc = ompi_datatype_create_struct(2, blklens, disps, types, &type_tmp);
+        rc = ompi_datatype_create_struct(2, OMPI_COUNT_ARRAY_CREATE(blklens), OMPI_DISP_ARRAY_CREATE(disps), types, &type_tmp);
         ompi_datatype_destroy(type_new);
         /* even in error condition, need to destroy type_new, so check
            for error after destroy. */
@@ -154,17 +168,17 @@ cyclic(const int *gsize_array, int dim, int ndims, int nprocs,
     disps[0] = 0;         disps[1] = orig_extent;
     if (order == MPI_ORDER_FORTRAN) {
         for(i=0; i<=dim; i++) {
-            disps[1] *= gsize_array[i];
+            disps[1] *= ompi_count_array_get(gsize_array, i);
         }
     } else {
         for(i=ndims-1; i>=dim; i--) {
-            disps[1] *= gsize_array[i];
+            disps[1] *= ompi_count_array_get(gsize_array, i);
         }
     }
     rc = opal_datatype_resize( &(*type_new)->super, disps[0], disps[1] );
     if (OMPI_SUCCESS != rc) return rc;
 
-    *st_offset = rank * blksize;
+    *st_offset = (ptrdiff_t) rank * blksize;
     /* in terms of no. of elements of type oldtype in this dimension */
     if (local_size == 0) *st_offset = 0;
 
@@ -174,10 +188,10 @@ cyclic(const int *gsize_array, int dim, int ndims, int nprocs,
 int32_t ompi_datatype_create_darray(int size,
                                     int rank,
                                     int ndims,
-                                    int const* gsize_array,
-                                    int const* distrib_array,
-                                    int const* darg_array,
-                                    int const* psize_array,
+                                    ompi_count_array_t gsize_array,
+                                    const int* distrib_array,
+                                    const int* darg_array,
+                                    const int* psize_array,
                                     int order,
                                     const ompi_datatype_t* oldtype,
                                     ompi_datatype_t** newtype)
@@ -209,7 +223,7 @@ int32_t ompi_datatype_create_darray(int size,
             coords[i] = tmp_rank / procs;
             tmp_rank = tmp_rank % procs;
             /* compute the upper bound of the datatype, including all dimensions */
-            displs[1] *= gsize_array[i];
+            displs[1] *= ompi_count_array_get(gsize_array, i);
         }
     }
 
@@ -275,7 +289,7 @@ int32_t ompi_datatype_create_darray(int size,
      */
     displs[0] = st_offsets[start_loop];
     for (i = start_loop + step; i != end_loop; i += step) {
-        tmp_size *= gsize_array[i - step];
+        tmp_size *= ompi_count_array_get(gsize_array, i - step);
         displs[0] += tmp_size * st_offsets[i];
     }
     displs[0] *= orig_extent;
diff --git a/ompi/datatype/ompi_datatype_create_indexed.c b/ompi/datatype/ompi_datatype_create_indexed.c
index 2684d9d7df0..29f8d8875c8 100644
--- a/ompi/datatype/ompi_datatype_create_indexed.c
+++ b/ompi/datatype/ompi_datatype_create_indexed.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2015-2017 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2019      IBM Corporation. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -31,38 +32,38 @@
 
 
 /* We try to merge together data that are contiguous */
-int32_t ompi_datatype_create_indexed( int count, const int* pBlockLength, const int* pDisp,
+int32_t ompi_datatype_create_indexed( size_t count, const ompi_count_array_t pBlockLength, const ompi_disp_array_t pDisp,
                                       const ompi_datatype_t* oldType, ompi_datatype_t** newType )
 {
     ptrdiff_t extent, disp, endat;
     ompi_datatype_t* pdt;
     size_t dLength;
-    int i;
+    size_t i;
 
     /* ignore all cases that lead to an empty type */
     ompi_datatype_type_size(oldType, &dLength);
-    for( i = 0; (i < count) && (0 == pBlockLength[i]); i++ );  /* find first non zero */
+    for( i = 0; (i < count) && (0 == ompi_count_array_get(pBlockLength, i)); i++ );  /* find first non zero */
     if( (i == count) || (0 == dLength) ) {
         return ompi_datatype_duplicate( &ompi_mpi_datatype_null.dt, newType);
     }
 
-    disp = pDisp[i];
-    dLength = pBlockLength[i];
+    disp = ompi_disp_array_get(pDisp, i);
+    dLength = ompi_count_array_get(pBlockLength, i);
     endat = disp + dLength;
     ompi_datatype_type_extent( oldType, &extent );
 
     pdt = ompi_datatype_create( (count - i) * (2 + oldType->super.desc.used) );
     for( i += 1; i < count; i++ ) {
-        if( 0 == pBlockLength[i] )  /* ignore empty length */
+        if( 0 == ompi_count_array_get(pBlockLength, i) )  /* ignore empty length */
             continue;
-        if( endat == pDisp[i] ) { /* contiguous with the previsious */
-            dLength += pBlockLength[i];
-            endat += pBlockLength[i];
+        if( endat == ompi_disp_array_get(pDisp, i) ) { /* contiguous with the previsious */
+            dLength += ompi_count_array_get(pBlockLength, i);
+            endat += ompi_count_array_get(pBlockLength, i);
         } else {
             ompi_datatype_add( pdt, oldType, dLength, disp * extent, extent );
-            disp = pDisp[i];
-            dLength = pBlockLength[i];
-            endat = disp + pBlockLength[i];
+            disp = ompi_disp_array_get(pDisp, i);
+            dLength = ompi_count_array_get(pBlockLength, i);
+            endat = disp + dLength;
         }
     }
     ompi_datatype_add( pdt, oldType, dLength, disp * extent, extent );
@@ -72,38 +73,38 @@ int32_t ompi_datatype_create_indexed( int count, const int* pBlockLength, const
 }
 
 
-int32_t ompi_datatype_create_hindexed( int count, const int* pBlockLength, const ptrdiff_t* pDisp,
+int32_t ompi_datatype_create_hindexed( size_t count, const ompi_count_array_t pBlockLength, const ompi_disp_array_t pDisp,
                                        const ompi_datatype_t* oldType, ompi_datatype_t** newType )
 {
     ptrdiff_t extent, disp, endat;
     ompi_datatype_t* pdt;
     size_t dLength;
-    int i;
+    size_t i;
 
     /* ignore all cases that lead to an empty type */
     ompi_datatype_type_size(oldType, &dLength);
-    for( i = 0; (i < count) && (0 == pBlockLength[i]); i++ );  /* find first non zero */
+    for( i = 0; (i < count) && (0 == ompi_count_array_get(pBlockLength, i)); i++ );  /* find first non zero */
     if( (i == count) || (0 == dLength) ) {
         return ompi_datatype_duplicate( &ompi_mpi_datatype_null.dt, newType);
     }
 
     ompi_datatype_type_extent( oldType, &extent );
-    disp = pDisp[i];
-    dLength = pBlockLength[i];
+    disp = ompi_disp_array_get(pDisp, i);
+    dLength = ompi_count_array_get(pBlockLength, i);
     endat = disp + dLength * extent;
 
     pdt = ompi_datatype_create( (count - i) * (2 + oldType->super.desc.used) );
     for( i += 1; i < count; i++ ) {
-        if( 0 == pBlockLength[i] )  /* ignore empty length */
+        if( 0 == ompi_count_array_get(pBlockLength, i) )  /* ignore empty length */
             continue;
-        if( endat == pDisp[i] ) { /* contiguous with the previsious */
-            dLength += pBlockLength[i];
-            endat += pBlockLength[i] * extent;
+        if( endat == ompi_disp_array_get(pDisp, i) ) { /* contiguous with the previsious */
+            dLength += ompi_count_array_get(pBlockLength, i);
+            endat += ompi_count_array_get(pBlockLength, i) * extent;
         } else {
             ompi_datatype_add( pdt, oldType, dLength, disp, extent );
-            disp = pDisp[i];
-            dLength = pBlockLength[i];
-            endat = disp + pBlockLength[i] * extent;
+            disp = ompi_disp_array_get(pDisp, i);
+            dLength = ompi_count_array_get(pBlockLength, i);
+            endat = disp + dLength * extent;
         }
     }
     ompi_datatype_add( pdt, oldType, dLength, disp, extent );
@@ -113,30 +114,30 @@ int32_t ompi_datatype_create_hindexed( int count, const int* pBlockLength, const
 }
 
 
-int32_t ompi_datatype_create_indexed_block( int count, int bLength, const int* pDisp,
+int32_t ompi_datatype_create_indexed_block( size_t count, size_t bLength, const ompi_disp_array_t pDisp,
                                             const ompi_datatype_t* oldType, ompi_datatype_t** newType )
 {
     ptrdiff_t extent, disp, endat;
     ompi_datatype_t* pdt;
     size_t dLength;
-    int i;
+    size_t i;
 
     if( (count == 0) || (bLength == 0) ) {
         return ompi_datatype_duplicate(&ompi_mpi_datatype_null.dt, newType);
     }
     ompi_datatype_type_extent( oldType, &extent );
     pdt = ompi_datatype_create( count * (2 + oldType->super.desc.used) );
-    disp = pDisp[0];
+    disp = ompi_disp_array_get(pDisp, 0);
     dLength = bLength;
     endat = disp + dLength;
     for( i = 1; i < count; i++ ) {
-        if( endat == pDisp[i] ) {
+        if( endat == ompi_disp_array_get(pDisp, i) ) {
             /* contiguous with the previsious */
             dLength += bLength;
             endat += bLength;
         } else {
             ompi_datatype_add( pdt, oldType, dLength, disp * extent, extent );
-            disp = pDisp[i];
+            disp = ompi_disp_array_get(pDisp, i);
             dLength = bLength;
             endat = disp + bLength;
         }
@@ -147,30 +148,30 @@ int32_t ompi_datatype_create_indexed_block( int count, int bLength, const int* p
     return OMPI_SUCCESS;
 }
 
-int32_t ompi_datatype_create_hindexed_block( int count, int bLength, const ptrdiff_t* pDisp,
+int32_t ompi_datatype_create_hindexed_block( size_t count, size_t bLength, const ompi_disp_array_t pDisp,
                                              const ompi_datatype_t* oldType, ompi_datatype_t** newType )
 {
     ptrdiff_t extent, disp, endat;
     ompi_datatype_t* pdt;
     size_t dLength;
-    int i;
+    size_t i;
 
     if( (count == 0) || (bLength == 0) ) {
         return ompi_datatype_duplicate(&ompi_mpi_datatype_null.dt, newType);
     }
     ompi_datatype_type_extent( oldType, &extent );
     pdt = ompi_datatype_create( count * (2 + oldType->super.desc.used) );
-    disp = pDisp[0];
+    disp = ompi_disp_array_get(pDisp, 0);
     dLength = bLength;
     endat = disp + dLength * extent;
     for( i = 1; i < count; i++ ) {
-        if( endat == pDisp[i] ) {
+        if( endat == ompi_disp_array_get(pDisp, i) ) {
             /* contiguous with the previsious */
             dLength += bLength;
             endat += bLength * extent;
         } else {
             ompi_datatype_add( pdt, oldType, dLength, disp, extent );
-            disp = pDisp[i];
+            disp = ompi_disp_array_get(pDisp, i);
             dLength = bLength;
             endat = disp + bLength * extent;
         }
diff --git a/ompi/datatype/ompi_datatype_create_struct.c b/ompi/datatype/ompi_datatype_create_struct.c
index 72d3251b936..bf4a05017c8 100644
--- a/ompi/datatype/ompi_datatype_create_struct.c
+++ b/ompi/datatype/ompi_datatype_create_struct.c
@@ -15,6 +15,7 @@
  * Copyright (c) 2010      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2017      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,16 +29,16 @@
 
 #include "ompi/datatype/ompi_datatype.h"
 
-int32_t ompi_datatype_create_struct( int count, const int* pBlockLength, const ptrdiff_t* pDisp,
+int32_t ompi_datatype_create_struct( size_t count, const ompi_count_array_t pBlockLength, const ompi_disp_array_t pDisp,
                                      ompi_datatype_t* const * pTypes, ompi_datatype_t** newType )
 {
     ptrdiff_t disp = 0, endto, lastExtent, lastDisp;
     ompi_datatype_t *pdt, *lastType;
-    int i, start_from;
+    size_t i, start_from;
     size_t lastBlock;
 
     /* Find first non-zero length element */
-    for( i = 0; (i < count) && (0 == pBlockLength[i]); i++ );
+    for( i = 0; (i < count) && (0 == ompi_count_array_get(pBlockLength, i)); i++ );
     if( i == count ) {  /* either nothing or nothing relevant */
         return ompi_datatype_duplicate( &ompi_mpi_datatype_null.dt, newType);
     }
@@ -46,22 +47,22 @@ int32_t ompi_datatype_create_struct( int count, const int* pBlockLength, const p
      */
     start_from = i;
     lastType = (ompi_datatype_t*)pTypes[start_from];
-    lastBlock = pBlockLength[start_from];
+    lastBlock = ompi_count_array_get(pBlockLength, start_from);
     lastExtent = lastType->super.ub - lastType->super.lb;
-    lastDisp = pDisp[start_from];
-    endto = pDisp[start_from] + lastExtent * lastBlock;
+    lastDisp = ompi_disp_array_get(pDisp, start_from);
+    endto = lastDisp + lastExtent * lastBlock;
 
     for( i = (start_from + 1); i < count; i++ ) {
-        if( (pTypes[i] == lastType) && (pDisp[i] == endto) ) {
-            lastBlock += pBlockLength[i];
+        if( (pTypes[i] == lastType) && (ompi_disp_array_get(pDisp, i) == endto) ) {
+            lastBlock += ompi_count_array_get(pBlockLength, i);
             endto = lastDisp + lastBlock * lastExtent;
         } else {
             disp += lastType->super.desc.used;
             if( lastBlock > 1 ) disp += 2;
             lastType = (ompi_datatype_t*)pTypes[i];
             lastExtent = lastType->super.ub - lastType->super.lb;
-            lastBlock = pBlockLength[i];
-            lastDisp = pDisp[i];
+            lastBlock = ompi_count_array_get(pBlockLength, i);
+            lastDisp = ompi_disp_array_get(pDisp, i);
             endto = lastDisp + lastExtent * lastBlock;
         }
     }
@@ -69,24 +70,24 @@ int32_t ompi_datatype_create_struct( int count, const int* pBlockLength, const p
     if( lastBlock != 1 ) disp += 2;
 
     lastType = (ompi_datatype_t*)pTypes[start_from];
-    lastBlock = pBlockLength[start_from];
+    lastBlock = ompi_count_array_get(pBlockLength, start_from);
     lastExtent = lastType->super.ub - lastType->super.lb;
-    lastDisp = pDisp[start_from];
-    endto = pDisp[start_from] + lastExtent * lastBlock;
+    lastDisp = ompi_disp_array_get(pDisp, start_from);
+    endto = lastDisp + lastExtent * lastBlock;
 
     pdt = ompi_datatype_create( (int32_t)disp );
 
     /* Do again the same loop but now add the elements */
     for( i = (start_from + 1); i < count; i++ ) {
-        if( (pTypes[i] == lastType) && (pDisp[i] == endto) ) {
-            lastBlock += pBlockLength[i];
+        if( (pTypes[i] == lastType) && (ompi_disp_array_get(pDisp, i) == endto) ) {
+            lastBlock += ompi_count_array_get(pBlockLength, i);
             endto = lastDisp + lastBlock * lastExtent;
         } else {
             ompi_datatype_add( pdt, lastType, lastBlock, lastDisp, lastExtent );
             lastType = (ompi_datatype_t*)pTypes[i];
             lastExtent = lastType->super.ub - lastType->super.lb;
-            lastBlock = pBlockLength[i];
-            lastDisp = pDisp[i];
+            lastBlock = ompi_count_array_get(pBlockLength, i);
+            lastDisp = ompi_disp_array_get(pDisp, i);
             endto = lastDisp + lastExtent * lastBlock;
         }
     }
diff --git a/ompi/datatype/ompi_datatype_create_subarray.c b/ompi/datatype/ompi_datatype_create_subarray.c
index fcf44407725..d82251e708c 100644
--- a/ompi/datatype/ompi_datatype_create_subarray.c
+++ b/ompi/datatype/ompi_datatype_create_subarray.c
@@ -15,6 +15,7 @@
  * Copyright (c) 2010      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2014-2015 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -29,9 +30,9 @@
 #include "ompi/datatype/ompi_datatype.h"
 
 int32_t ompi_datatype_create_subarray(int ndims,
-                                      int const* size_array,
-                                      int const* subsize_array,
-                                      int const* start_array,
+                                      const ompi_count_array_t size_array,
+                                      const ompi_count_array_t subsize_array,
+                                      const ompi_count_array_t start_array,
                                       int order,
                                       const ompi_datatype_t* oldtype,
                                       ompi_datatype_t** newtype)
@@ -54,9 +55,9 @@ int32_t ompi_datatype_create_subarray(int ndims,
             ompi_datatype_duplicate(&ompi_mpi_datatype_null.dt, newtype);
             return MPI_SUCCESS;
         }
-        ompi_datatype_create_contiguous( subsize_array[0], oldtype, &last_type );
-        size = size_array[0];
-        displ = start_array[0];
+        ompi_datatype_create_contiguous( ompi_count_array_get(subsize_array, 0), oldtype, &last_type );
+        size = ompi_count_array_get(size_array, 0);
+        displ = ompi_count_array_get(start_array, 0);
         goto replace_subarray_type;
     }
 
@@ -74,19 +75,22 @@ int32_t ompi_datatype_create_subarray(int ndims,
      * first dimension data outside the loop, such that we dont have to create
      * a duplicate of the oldtype just to be able to free it.
      */
-    ompi_datatype_create_vector( subsize_array[i+step], subsize_array[i], size_array[i],
+    ompi_datatype_create_vector( ompi_count_array_get(subsize_array, i+step),
+                                 ompi_count_array_get(subsize_array, i),
+                                 ompi_count_array_get(size_array, i),
                                  oldtype, newtype );
 
     last_type = *newtype;
-    size = (MPI_Aint)size_array[i] * (MPI_Aint)size_array[i+step];
-    displ = (MPI_Aint)start_array[i] + (MPI_Aint)start_array[i+step] * (MPI_Aint)size_array[i];
+    size = (MPI_Aint)ompi_count_array_get(size_array, i) * (MPI_Aint)ompi_count_array_get(size_array, i+step);
+    displ = (MPI_Aint)ompi_count_array_get(start_array, i)
+            + (MPI_Aint)ompi_count_array_get(start_array, i+step) * (MPI_Aint)ompi_count_array_get(size_array, i);
     for( i += 2 * step; i != end_loop; i += step ) {
-        ompi_datatype_create_hvector( subsize_array[i], 1, size * extent,
+        ompi_datatype_create_hvector( ompi_count_array_get(subsize_array, i), 1, size * extent,
                                       last_type, newtype );
         ompi_datatype_destroy( &last_type );
 
-        displ += size * start_array[i];
-        size *= size_array[i];
+        displ += size * ompi_count_array_get(start_array, i);
+        size *= ompi_count_array_get(size_array, i);
         last_type = *newtype;
     }
 
diff --git a/ompi/datatype/ompi_datatype_create_vector.c b/ompi/datatype/ompi_datatype_create_vector.c
index c4829a4b54c..134bcfc50e5 100644
--- a/ompi/datatype/ompi_datatype_create_vector.c
+++ b/ompi/datatype/ompi_datatype_create_vector.c
@@ -15,6 +15,7 @@
  * Copyright (c) 2010      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2017      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,7 +29,7 @@
 
 #include "ompi/datatype/ompi_datatype.h"
 
-int32_t ompi_datatype_create_vector( int count, int bLength, int stride,
+int32_t ompi_datatype_create_vector( size_t count, size_t bLength, ptrdiff_t stride,
                                      const ompi_datatype_t* oldType, ompi_datatype_t** newType )
 {
     ompi_datatype_t *pTempData, *pData;
@@ -39,7 +40,7 @@ int32_t ompi_datatype_create_vector( int count, int bLength, int stride,
     }
 
     pData = ompi_datatype_create( oldType->super.desc.used + 2 );
-    if( (bLength == stride) || (1 >= count) ) {  /* the elements are contiguous */
+    if( (bLength == (size_t)stride) || (1 >= count) ) {  /* the elements are contiguous */
         ompi_datatype_add( pData, oldType, (size_t)count * bLength, 0, extent );
     } else {
         if( 1 == bLength ) {
@@ -57,7 +58,7 @@ int32_t ompi_datatype_create_vector( int count, int bLength, int stride,
 }
 
 
-int32_t ompi_datatype_create_hvector( int count, int bLength, ptrdiff_t stride,
+int32_t ompi_datatype_create_hvector( size_t count, size_t bLength, ptrdiff_t stride,
                                       const ompi_datatype_t* oldType, ompi_datatype_t** newType )
 {
     ompi_datatype_t *pTempData, *pData;
@@ -68,7 +69,7 @@ int32_t ompi_datatype_create_hvector( int count, int bLength, ptrdiff_t stride,
     }
 
     pTempData = ompi_datatype_create( oldType->super.desc.used + 2 );
-    if( ((extent * bLength) == stride) || (1 >= count) ) {  /* contiguous */
+    if( ((extent * bLength) == (size_t)stride) || (1 >= count) ) {  /* contiguous */
         pData = pTempData;
         ompi_datatype_add( pData, oldType, count * bLength, 0, extent );
     } else {
diff --git a/ompi/datatype/ompi_datatype_match_size.c b/ompi/datatype/ompi_datatype_match_size.c
index 1e036c7003b..6aefb33f6e5 100644
--- a/ompi/datatype/ompi_datatype_match_size.c
+++ b/ompi/datatype/ompi_datatype_match_size.c
@@ -12,6 +12,8 @@
  *                         All rights reserved.
  * Copyright (c) 2009      Sun Microsystems, Inc. All rights reserved.
  * Copyright (c) 2009      Oak Ridge National Labs.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 
 extern int32_t ompi_datatype_number_of_predefined_data;
 
-const ompi_datatype_t* ompi_datatype_match_size( int size, uint16_t datakind, uint16_t datalang )
+const ompi_datatype_t* ompi_datatype_match_size( size_t size, uint16_t datakind, uint16_t datalang )
 {
     int32_t i;
     const ompi_datatype_t* datatype;
@@ -41,11 +43,21 @@ const ompi_datatype_t* ompi_datatype_match_size( int size, uint16_t datakind, ui
 
         datatype = (ompi_datatype_t*)opal_pointer_array_get_item(&ompi_datatype_f_to_c_table, i);
 
+        /* Only basic scalar predefined types are valid matches for a
+         * (typeclass, size) request.  Requiring OPAL_DATATYPE_FLAG_BASIC
+         * skips two kinds of entries that would otherwise produce bogus
+         * matches: types that are unavailable in this build (e.g. the
+         * Fortran types in a --disable-mpi-fortran build, which have size 0
+         * and would spuriously match a size-0 request), and composite
+         * predefined types (e.g. MPI_2REAL, a pair of REALs whose 8-byte
+         * size would otherwise be returned for a request of REAL/8). */
+        if( (datatype->super.flags & OPAL_DATATYPE_FLAG_BASIC) != OPAL_DATATYPE_FLAG_BASIC )
+            continue;
         if( (datatype->super.flags & OMPI_DATATYPE_FLAG_DATA_LANGUAGE) != datalang )
             continue;
         if( (datatype->super.flags & OMPI_DATATYPE_FLAG_DATA_TYPE) != datakind )
             continue;
-        if( (size_t)size == datatype->super.size ) {
+        if( size == datatype->super.size ) {
             return datatype;
         }
     }
diff --git a/ompi/datatype/ompi_datatype_module.c b/ompi/datatype/ompi_datatype_module.c
index 2a11e6ef090..3cf875069a5 100644
--- a/ompi/datatype/ompi_datatype_module.c
+++ b/ompi/datatype/ompi_datatype_module.c
@@ -22,6 +22,7 @@
  *                         reserved.
  * Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
  * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -441,7 +442,9 @@ opal_pointer_array_t ompi_datatype_f_to_c_table = {{0}};
         displ[1] = (ptrdiff_t)(&(s[0].v2));                                          \
         displ[1] -= base;                                                            \
                                                                                      \
-        ompi_datatype_create_struct( 2, bLength, displ, types, &ptype );             \
+        ompi_datatype_create_struct( 2, OMPI_COUNT_ARRAY_CREATE(bLength),            \
+                                     OMPI_DISP_ARRAY_CREATE(displ), types,           \
+                                     &ptype );                                       \
         displ[0] = (ptrdiff_t)(&(s[1]));                                             \
         displ[0] -= base;                                                            \
         if( displ[0] != (displ[1] + (ptrdiff_t)sizeof(type2)) )                      \
diff --git a/ompi/datatype/ompi_datatype_sndrcv.c b/ompi/datatype/ompi_datatype_sndrcv.c
index 967c7509271..c8877a9cf33 100644
--- a/ompi/datatype/ompi_datatype_sndrcv.c
+++ b/ompi/datatype/ompi_datatype_sndrcv.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2009      Oak Ridge National Labs.  All rights reserved.
  * Copyright (c) 2014-2015 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -42,8 +43,8 @@
  *           - communicator
  * Returns:  - MPI_SUCCESS or error code
  */
-int32_t ompi_datatype_sndrcv( const void *sbuf, int32_t scount, const ompi_datatype_t* sdtype,
-                              void *rbuf, int32_t rcount, const ompi_datatype_t* rdtype)
+int32_t ompi_datatype_sndrcv( const void *sbuf, size_t scount, const ompi_datatype_t* sdtype,
+                              void *rbuf, size_t rcount, const ompi_datatype_t* rdtype)
 {
     opal_convertor_t send_convertor, recv_convertor;
     struct iovec iov;
@@ -73,11 +74,11 @@ int32_t ompi_datatype_sndrcv( const void *sbuf, int32_t scount, const ompi_datat
         iov_count = 1;
         iov.iov_base = (IOVBASE_TYPE*)rbuf;
         iov.iov_len = scount * sdtype->super.size;
-        if( (int32_t)iov.iov_len > rcount ) iov.iov_len = rcount;
+        if( iov.iov_len > rcount ) iov.iov_len = rcount;
 
         opal_convertor_pack( &send_convertor, &iov, &iov_count, &max_data );
         OBJ_DESTRUCT( &send_convertor );
-        return ((max_data < (size_t)rcount) ? MPI_ERR_TRUNCATE : MPI_SUCCESS);
+        return ((max_data < rcount) ? MPI_ERR_TRUNCATE : MPI_SUCCESS);
     }
 
     /* If send packed. */
@@ -90,11 +91,11 @@ int32_t ompi_datatype_sndrcv( const void *sbuf, int32_t scount, const ompi_datat
         iov_count = 1;
         iov.iov_base = (IOVBASE_TYPE*)sbuf;
         iov.iov_len = rcount * rdtype->super.size;
-        if( (int32_t)iov.iov_len > scount ) iov.iov_len = scount;
+        if( iov.iov_len > scount ) iov.iov_len = scount;
 
         opal_convertor_unpack( &recv_convertor, &iov, &iov_count, &max_data );
         OBJ_DESTRUCT( &recv_convertor );
-        return (((size_t)scount > max_data) ? MPI_ERR_TRUNCATE : MPI_SUCCESS);
+        return ((scount > max_data) ? MPI_ERR_TRUNCATE : MPI_SUCCESS);
     }
 
     iov.iov_len = length = 64 * 1024;
diff --git a/ompi/errhandler/errcode.c b/ompi/errhandler/errcode.c
index 8c6a13cdb82..d04b6f9069c 100644
--- a/ompi/errhandler/errcode.c
+++ b/ompi/errhandler/errcode.c
@@ -129,6 +129,9 @@ static ompi_mpi_errcode_t ompi_err_revoked;
 static ompi_mpi_errcode_t ompi_err_session;
 static ompi_mpi_errcode_t ompi_err_value_too_large;
 static ompi_mpi_errcode_t ompi_err_errhandler;
+static ompi_mpi_errcode_t ompi_t_err_not_accessible;
+static ompi_mpi_errcode_t ompi_t_err_not_supported;
+static ompi_mpi_errcode_t ompi_err_rma_notification;
 
 static void ompi_mpi_errcode_construct(ompi_mpi_errcode_t* errcode);
 static void ompi_mpi_errcode_destruct(ompi_mpi_errcode_t* errcode);
@@ -248,6 +251,9 @@ int ompi_mpi_errcode_init (void)
     CONSTRUCT_ERRCODE( ompi_err_session,  MPI_ERR_SESSION,  "MPI_ERR_SESSION: Invalid session handle" );
     CONSTRUCT_ERRCODE( ompi_err_value_too_large,  MPI_ERR_VALUE_TOO_LARGE,  "MPI_ERR_VALUE_TOO_LARGE: Value is too large to store" );
     CONSTRUCT_ERRCODE( ompi_err_errhandler,  MPI_ERR_ERRHANDLER,  "MPI_ERR_ERRHANDLER: Invalid error handler handle" );
+    CONSTRUCT_ERRCODE( ompi_t_err_not_accessible, MPI_T_ERR_NOT_ACCESSIBLE, "MPI_T_ERR_NOT_ACCESSIBLE: Requested functionality is not accessible" );
+    CONSTRUCT_ERRCODE( ompi_t_err_not_supported, MPI_T_ERR_NOT_SUPPORTED, "MPI_T_ERR_NOT_SUPPORTED: Requested functionality not supported" );
+    CONSTRUCT_ERRCODE( ompi_err_rma_notification,  MPI_ERR_RMA_NOTIFICATION,  "MPI_ERR_RMA_NOTIFICATION: Invalid notification index passed to MPI call" );
 
     /* Per MPI-3 p353:27-32, MPI_LASTUSEDCODE must be >=
        MPI_ERR_LASTCODE.  So just start it as == MPI_ERR_LASTCODE. */
@@ -367,6 +373,9 @@ int ompi_mpi_errcode_finalize (void)
     OBJ_DESTRUCT(&ompi_err_session);
     OBJ_DESTRUCT(&ompi_err_value_too_large);
     OBJ_DESTRUCT(&ompi_err_errhandler);
+    OBJ_DESTRUCT(&ompi_t_err_not_accessible);
+    OBJ_DESTRUCT(&ompi_t_err_not_supported);
+    OBJ_DESTRUCT(&ompi_err_rma_notification);
     OBJ_DESTRUCT(&ompi_mpi_errcodes);
     ompi_mpi_errcode_lastpredefined = 0;
     opal_mutex_unlock(&errcode_lock);
diff --git a/ompi/errhandler/errhandler.c b/ompi/errhandler/errhandler.c
index 17fd48dbe9b..4130c9d7d5b 100644
--- a/ompi/errhandler/errhandler.c
+++ b/ompi/errhandler/errhandler.c
@@ -202,6 +202,7 @@ int ompi_errhandler_init(void)
   ompi_mpi_errors_abort.eh.eh_comm_fn = ompi_mpi_errors_abort_comm_handler;
   ompi_mpi_errors_abort.eh.eh_file_fn = ompi_mpi_errors_abort_file_handler;
   ompi_mpi_errors_abort.eh.eh_win_fn  = ompi_mpi_errors_abort_win_handler ;
+  ompi_mpi_errors_abort.eh.eh_instance_fn = ompi_mpi_errors_abort_instance_handler;
   ompi_mpi_errors_abort.eh.eh_fort_fn = NULL;
   opal_string_copy(ompi_mpi_errors_abort.eh.eh_name,
                    "MPI_ERRORS_ABORT",
diff --git a/ompi/errhandler/errhandler_invoke.c b/ompi/errhandler/errhandler_invoke.c
index 7cb4e343d50..e4ffd0b96ce 100644
--- a/ompi/errhandler/errhandler_invoke.c
+++ b/ompi/errhandler/errhandler_invoke.c
@@ -85,13 +85,17 @@ int ompi_errhandler_invoke(ompi_errhandler_t *errhandler, void *mpi_object,
         comm = (ompi_communicator_t *) mpi_object;
         switch (errhandler->eh_lang) {
         case OMPI_ERRHANDLER_LANG_C:
-            errhandler->eh_comm_fn(&comm, &err_code, message, NULL);
+            if (NULL != errhandler->eh_comm_fn) {
+                errhandler->eh_comm_fn(&comm, &err_code, message, NULL);
+            }
             break;
 
         case OMPI_ERRHANDLER_LANG_FORTRAN:
-            fortran_handle = OMPI_INT_2_FINT(comm->c_f_to_c_index);
-            errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
-            err_code = OMPI_FINT_2_INT(fortran_err_code);
+            if (NULL != errhandler->eh_fort_fn) {
+                fortran_handle = OMPI_INT_2_FINT(comm->c_f_to_c_index);
+                errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
+                err_code = OMPI_FINT_2_INT(fortran_err_code);
+            }
             break;
         }
         break;
@@ -100,13 +104,17 @@ int ompi_errhandler_invoke(ompi_errhandler_t *errhandler, void *mpi_object,
         win = (ompi_win_t *) mpi_object;
         switch (errhandler->eh_lang) {
         case OMPI_ERRHANDLER_LANG_C:
-            errhandler->eh_win_fn(&win, &err_code, message, NULL);
+            if (NULL != errhandler->eh_win_fn) {
+                errhandler->eh_win_fn(&win, &err_code, message, NULL);
+            }
             break;
 
         case OMPI_ERRHANDLER_LANG_FORTRAN:
-            fortran_handle = OMPI_INT_2_FINT(win->w_f_to_c_index);
-            errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
-            err_code = OMPI_FINT_2_INT(fortran_err_code);
+            if (NULL != errhandler->eh_fort_fn) {
+                fortran_handle = OMPI_INT_2_FINT(win->w_f_to_c_index);
+                errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
+                err_code = OMPI_FINT_2_INT(fortran_err_code);
+            }
             break;
         }
         break;
@@ -115,13 +123,17 @@ int ompi_errhandler_invoke(ompi_errhandler_t *errhandler, void *mpi_object,
         file = (ompi_file_t *) mpi_object;
         switch (errhandler->eh_lang) {
         case OMPI_ERRHANDLER_LANG_C:
-            errhandler->eh_file_fn(&file, &err_code, message, NULL);
+            if (NULL != errhandler->eh_file_fn) {
+                errhandler->eh_file_fn(&file, &err_code, message, NULL);
+            }
             break;
 
         case OMPI_ERRHANDLER_LANG_FORTRAN:
-            fortran_handle = OMPI_INT_2_FINT(file->f_f_to_c_index);
-            errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
-            err_code = OMPI_FINT_2_INT(fortran_err_code);
+            if (NULL != errhandler->eh_fort_fn) {
+                fortran_handle = OMPI_INT_2_FINT(file->f_f_to_c_index);
+                errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
+                err_code = OMPI_FINT_2_INT(fortran_err_code);
+            }
             break;
         }
         break;
@@ -130,13 +142,17 @@ int ompi_errhandler_invoke(ompi_errhandler_t *errhandler, void *mpi_object,
         instance = (ompi_instance_t *) mpi_object;
         switch (errhandler->eh_lang) {
         case OMPI_ERRHANDLER_LANG_C:
-            errhandler->eh_instance_fn(&instance, &err_code, message, NULL);
+            if (NULL != errhandler->eh_instance_fn) {
+                errhandler->eh_instance_fn(&instance, &err_code, message, NULL);
+            }
             break;
 
         case OMPI_ERRHANDLER_LANG_FORTRAN:
-            fortran_handle = OMPI_INT_2_FINT(instance->i_f_to_c_index);
-            errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
-            err_code = OMPI_FINT_2_INT(fortran_err_code);
+            if (NULL != errhandler->eh_fort_fn) {
+                fortran_handle = OMPI_INT_2_FINT(instance->i_f_to_c_index);
+                errhandler->eh_fort_fn(&fortran_handle, &fortran_err_code);
+                err_code = OMPI_FINT_2_INT(fortran_err_code);
+            }
             break;
         }
         break;
@@ -227,4 +243,4 @@ int ompi_errhandler_request_invoke(int count,
                                       ec, message);
         break;
     }
-}
+}
\ No newline at end of file
diff --git a/ompi/errhandler/errhandler_predefined.c b/ompi/errhandler/errhandler_predefined.c
index 759025d4bd8..e32a358280c 100644
--- a/ompi/errhandler/errhandler_predefined.c
+++ b/ompi/errhandler/errhandler_predefined.c
@@ -48,6 +48,7 @@
 #include "opal/util/printf.h"
 #include "opal/util/output.h"
 #include "ompi/runtime/mpiruntime.h"
+#include "ompi/proc/proc.h"
 
 /*
  * Local functions
@@ -185,6 +186,54 @@ void ompi_mpi_errors_abort_win_handler(struct ompi_win_t **win,
   va_end(arglist);
 }
 
+void ompi_mpi_errors_abort_instance_handler(struct ompi_instance_t **instance,
+                                            int *error_code, ...)
+{
+  char *name;
+  va_list arglist;
+  int err = MPI_ERR_UNKNOWN;
+  opal_proc_t *local_proc;
+  pmix_proc_t my_pmix_proc = PMIX_PROC_STATIC_INIT;
+
+  va_start(arglist, error_code);
+
+  if (NULL != instance && NULL != *instance) {
+      name = (*instance)->i_name;
+  } else {
+      name = NULL;
+  }
+
+  if (NULL != error_code) {
+     err = *error_code;
+  }
+
+  /* We only want aggregation while the rte is initialized */
+  if (ompi_rte_initialized) {
+      backend_abort_aggregate(false, "session", NULL, name, error_code, arglist);
+  } else {
+      backend_abort_no_aggregate(false, "session", NULL, name, error_code, arglist);
+  }
+
+  va_end(arglist);
+
+  /* 
+   * MPI-5.0 Sec 9.3 (pp.447-448): ERRORS_ABORT on a session aborts ONLY the
+   * local MPI process.  We signal the PMIx runtime that the local process
+   * is to be aborted by explicitly specifying the pmix_proc_t of the local
+   * process in the call to PMIx_Abort.  Note that when using the PRRTe
+   * PMIx server one must use the mpirun --enable-recovery option
+   * to prevent the server from aborting the other processes in the job.
+   */
+
+  local_proc = opal_proc_local_get();
+  OPAL_PMIX_CONVERT_NAME(&my_pmix_proc, &local_proc->proc_name);
+  PMIx_Abort(err, NULL, &my_pmix_proc, 1);
+
+  /* Now Exit */
+  _exit(err);
+
+}
+
 void ompi_mpi_errors_are_fatal_instance_handler (struct ompi_instance_t **instance,
                                                  int *error_code, ...)
 {
diff --git a/ompi/errhandler/errhandler_predefined.h b/ompi/errhandler/errhandler_predefined.h
index c663d962220..4c029e6710a 100644
--- a/ompi/errhandler/errhandler_predefined.h
+++ b/ompi/errhandler/errhandler_predefined.h
@@ -50,6 +50,8 @@ OMPI_DECLSPEC void ompi_mpi_errors_abort_file_handler(struct ompi_file_t **file,
 					    int *error_code, ...);
 OMPI_DECLSPEC void ompi_mpi_errors_abort_win_handler(struct ompi_win_t **win,
 					    int *error_code, ...);
+OMPI_DECLSPEC void ompi_mpi_errors_abort_instance_handler(struct ompi_instance_t **instance,
+					    int *error_code, ...);
 
 /**
  * Handler function for MPI_ERRORS_RETURN
diff --git a/ompi/include/mpi.h.in b/ompi/include/mpi.h.in
index e06865b182f..59b80615828 100644
--- a/ompi/include/mpi.h.in
+++ b/ompi/include/mpi.h.in
@@ -30,6 +30,7 @@
  * Copyright (c) 2025      Advanced Micro Devices, Inc. All rights reserved
  * Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
  * Copyright (c) 2025      UT-Battelle, LLC.  All rights reserved.
+ * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -657,7 +658,7 @@ typedef MPI_Win_errhandler_function MPI_Win_errhandler_fn
 enum {
     /* MPI-1 */
     MPI_TAG_UB,
-    MPI_HOST __mpi_interface_deprecated_in_mpi41__("MPI_HOST is deprecated since MPI 4.1"), 
+    MPI_HOST __mpi_interface_deprecated_in_mpi41__("MPI_HOST is deprecated since MPI 4.1"),
     MPI_IO,
     MPI_WTIME_IS_GLOBAL,
 
@@ -673,6 +674,12 @@ enum {
 
     /* MPI-4 */
     MPI_FT, /* used by OPAL_ENABLE_FT_MPI */
+
+    /* MPI-5.1 used in notified RMA */
+    MPI_WIN_NOTIFICATION_NUM_SB,
+    MPI_WIN_NOTIFICATION_NUM_UB,
+    MPI_WIN_NOTIFICATION_VALUE_UB,
+
     MPI_ATTR_PREDEFINED_KEY_MAX,
 };
 
@@ -764,6 +771,9 @@ enum {
 #define MPI_ERR_SESSION               78
 #define MPI_ERR_VALUE_TOO_LARGE       79
 #define MPI_ERR_ERRHANDLER            80
+#define MPI_T_ERR_NOT_ACCESSIBLE      81
+#define MPI_T_ERR_NOT_SUPPORTED       82
+#define MPI_ERR_RMA_NOTIFICATION      83
 
 /* Per MPI-3 p349 47, MPI_ERR_LASTCODE must be >= the last predefined
    MPI_ERR_<foo> code. Set the last code to allow some room for adding
@@ -868,7 +878,8 @@ enum {
   OMPI_COMM_TYPE_CLUSTER,
   MPI_COMM_TYPE_HW_UNGUIDED,
   MPI_COMM_TYPE_HW_GUIDED,
-  MPI_COMM_TYPE_RESOURCE_GUIDED
+  MPI_COMM_TYPE_RESOURCE_GUIDED,
+  OMPI_COMM_TYPE_NVLINK
 };
 #define OMPI_COMM_TYPE_NODE MPI_COMM_TYPE_SHARED
 
@@ -1458,6 +1469,14 @@ OMPI_DECLSPEC  int MPI_Accumulate(const void *origin_addr, int origin_count, MPI
 OMPI_DECLSPEC  int MPI_Accumulate_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                                     int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                     MPI_Datatype target_datatype, MPI_Op op, MPI_Win win);
+OMPI_DECLSPEC  int MPI_Accumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                         int target_rank, MPI_Aint target_disp, int target_count,
+                                         MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                         MPI_Win win);
+OMPI_DECLSPEC  int MPI_Accumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                           int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                           MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                           MPI_Win win);
 OMPI_DECLSPEC  int MPI_Add_error_class(int *errorclass);
 OMPI_DECLSPEC  int MPI_Add_error_code(int errorclass, int *errorcode);
 OMPI_DECLSPEC  int MPI_Add_error_string(int errorcode, const char *string);
@@ -1917,6 +1936,14 @@ OMPI_DECLSPEC  int MPI_Get_c(void *origin_addr, MPI_Count origin_count,
                              MPI_Datatype origin_datatype, int target_rank,
                              MPI_Aint target_disp, MPI_Count target_count,
                              MPI_Datatype target_datatype, MPI_Win win);
+OMPI_DECLSPEC  int MPI_Get_notify(void *origin_addr, int origin_count,
+                                       MPI_Datatype origin_datatype, int target_rank,
+                                       MPI_Aint target_disp, int target_count,
+                                       MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
+OMPI_DECLSPEC  int MPI_Get_notify_c(void *origin_addr, MPI_Count origin_count,
+                                         MPI_Datatype origin_datatype, int target_rank,
+                                         MPI_Aint target_disp, MPI_Count target_count,
+                                         MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
 OMPI_DECLSPEC  int MPI_Get_accumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                                       void *result_addr, int result_count, MPI_Datatype result_datatype,
                                       int target_rank, MPI_Aint target_disp, int target_count,
@@ -1925,6 +1952,16 @@ OMPI_DECLSPEC  int MPI_Get_accumulate_c(const void *origin_addr, MPI_Count origi
                                         void *result_addr, MPI_Count result_count, MPI_Datatype result_datatype,
                                         int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                         MPI_Datatype target_datatype, MPI_Op op, MPI_Win win);
+OMPI_DECLSPEC  int MPI_Get_accumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                             void *result_addr, int result_count, MPI_Datatype result_datatype,
+                                             int target_rank, MPI_Aint target_disp, int target_count,
+                                             MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                             MPI_Win win);
+OMPI_DECLSPEC  int MPI_Get_accumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                               void *result_addr, MPI_Count result_count, MPI_Datatype result_datatype,
+                                               int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                               MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                               MPI_Win win);
 OMPI_DECLSPEC  int MPI_Get_library_version(char *version, int *resultlen);
 OMPI_DECLSPEC  int MPI_Get_processor_name(char *name, int *resultlen);
 OMPI_DECLSPEC  int MPI_Get_version(int *version, int *subversion);
@@ -2180,6 +2217,12 @@ OMPI_DECLSPEC  int MPI_Put(const void *origin_addr, int origin_count, MPI_Dataty
 OMPI_DECLSPEC  int MPI_Put_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                              int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                              MPI_Datatype target_datatype, MPI_Win win);
+OMPI_DECLSPEC  int MPI_Put_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                       int target_rank, MPI_Aint target_disp, int target_count,
+                                       MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
+OMPI_DECLSPEC  int MPI_Put_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                         int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                         MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
 OMPI_DECLSPEC  int MPI_Query_thread(int *provided);
 OMPI_DECLSPEC  int MPI_Raccumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                                    int target_rank, MPI_Aint target_disp, int target_count,
@@ -2187,6 +2230,14 @@ OMPI_DECLSPEC  int MPI_Raccumulate(const void *origin_addr, int origin_count, MP
 OMPI_DECLSPEC  int MPI_Raccumulate_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                                      int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                      MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Raccumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                          int target_rank, MPI_Aint target_disp, int target_count,
+                                          MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                          MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Raccumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                            int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                            MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                            MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int MPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int source,
                                  int tag, MPI_Comm comm, MPI_Request *request);
 OMPI_DECLSPEC  int MPI_Recv_init_c(void *buf, MPI_Count count, MPI_Datatype datatype, int source,
@@ -2265,6 +2316,14 @@ OMPI_DECLSPEC  int MPI_Rget(void *origin_addr, int origin_count, MPI_Datatype or
 OMPI_DECLSPEC  int MPI_Rget_c(void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                               int target_rank, MPI_Aint target_disp, MPI_Count target_count, MPI_Datatype target_datatype,
                               MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Rget_notify(void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                   int target_rank, MPI_Aint target_disp, int target_count,
+                                   MPI_Datatype target_datatype, int notification_idx,
+                                   MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Rget_notify_c(void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                     int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                     MPI_Datatype target_datatype, int notification_idx,
+                                     MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int MPI_Rget_accumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                                        void *result_addr, int result_count, MPI_Datatype result_datatype,
                                        int target_rank, MPI_Aint target_disp, int target_count,
@@ -2275,12 +2334,30 @@ OMPI_DECLSPEC  int MPI_Rget_accumulate_c(const void *origin_addr, MPI_Count orig
                                          int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                          MPI_Datatype target_datatype, MPI_Op op,
                                          MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Rget_accumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                              void *result_addr, int result_count, MPI_Datatype result_datatype,
+                                              int target_rank, MPI_Aint target_disp, int target_count,
+                                              MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                              MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Rget_accumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                                void *result_addr, MPI_Count result_count, MPI_Datatype result_datatype,
+                                                int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                                MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                                MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int MPI_Rput(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                             int target_rank, MPI_Aint target_disp, int target_cout,
                             MPI_Datatype target_datatype, MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int MPI_Rput_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                               int target_rank, MPI_Aint target_disp, MPI_Count target_cout,
                               MPI_Datatype target_datatype, MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Rput_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                   int target_rank, MPI_Aint target_disp, int target_count,
+                                   MPI_Datatype target_datatype, int notification_idx,
+                                   MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int MPI_Rput_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                     int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                     MPI_Datatype target_datatype, int notification_idx,
+                                     MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int MPI_Rsend(const void *ibuf, int count, MPI_Datatype datatype, int dest,
                              int tag, MPI_Comm comm);
 OMPI_DECLSPEC  int MPI_Rsend_c(const void *ibuf, MPI_Count count, MPI_Datatype datatype, int dest,
@@ -2363,7 +2440,7 @@ OMPI_DECLSPEC  int MPI_Sendrecv_replace(void * buf, int count, MPI_Datatype data
 OMPI_DECLSPEC  int MPI_Sendrecv_replace_c(void * buf, MPI_Count count, MPI_Datatype datatype,
                                           int dest, int sendtag, int source, int recvtag,
                                           MPI_Comm comm, MPI_Status *status);
-OMPI_DECLSPEC  MPI_Fint MPI_Session_c2f (const MPI_Session session);
+OMPI_DECLSPEC  MPI_Fint MPI_Session_c2f (MPI_Session session);
 OMPI_DECLSPEC  int MPI_Session_attach_buffer(MPI_Session session, void *buffer, int size);
 OMPI_DECLSPEC  int MPI_Session_attach_buffer_c(MPI_Session session, void *buffer, MPI_Count size);
 OMPI_DECLSPEC  int MPI_Session_call_errhandler(MPI_Session session, int errorcode);
@@ -2604,6 +2681,10 @@ OMPI_DECLSPEC  int MPI_Win_get_errhandler(MPI_Win win, MPI_Errhandler *errhandle
 OMPI_DECLSPEC  int MPI_Win_get_group(MPI_Win win, MPI_Group *group);
 OMPI_DECLSPEC  int MPI_Win_get_info(MPI_Win win, MPI_Info *info_used);
 OMPI_DECLSPEC  int MPI_Win_get_name(MPI_Win win, char *win_name, int *resultlen);
+OMPI_DECLSPEC  int MPI_Win_get_notify_value(MPI_Win win, int notification_idx, MPI_Count *value);
+OMPI_DECLSPEC  int MPI_Win_reset_notify_value(MPI_Win win, int notification_idx, MPI_Count *value);
+OMPI_DECLSPEC  int MPI_Win_get_num_notify(MPI_Win win, int target_rank, int *num_notifications);
+OMPI_DECLSPEC  int MPI_Win_set_num_notify(MPI_Win win, MPI_Info info, int num_notifications);
 OMPI_DECLSPEC  int MPI_Win_lock(int lock_type, int rank, int mpi_assert, MPI_Win win);
 OMPI_DECLSPEC  int MPI_Win_lock_all(int mpi_assert, MPI_Win win);
 OMPI_DECLSPEC  int MPI_Win_post(MPI_Group group, int mpi_assert, MPI_Win win);
@@ -2632,6 +2713,14 @@ OMPI_DECLSPEC  int PMPI_Accumulate(const void *origin_addr, int origin_count, MP
 OMPI_DECLSPEC  int PMPI_Accumulate_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                                      int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                      MPI_Datatype target_datatype, MPI_Op op, MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Accumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                          int target_rank, MPI_Aint target_disp, int target_count,
+                                          MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                          MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Accumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                            int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                            MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                            MPI_Win win);
 OMPI_DECLSPEC  int PMPI_Add_error_class(int *errorclass);
 OMPI_DECLSPEC  int PMPI_Add_error_code(int errorclass, int *errorcode);
 OMPI_DECLSPEC  int PMPI_Add_error_string(int errorcode, const char *string);
@@ -3091,6 +3180,14 @@ OMPI_DECLSPEC  int PMPI_Get_c(void *origin_addr, MPI_Count origin_count,
                               MPI_Datatype origin_datatype, int target_rank,
                               MPI_Aint target_disp, MPI_Count target_count,
                               MPI_Datatype target_datatype, MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Get_notify(void *origin_addr, int origin_count,
+                                        MPI_Datatype origin_datatype, int target_rank,
+                                        MPI_Aint target_disp, int target_count,
+                                        MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Get_notify_c(void *origin_addr, MPI_Count origin_count,
+                                          MPI_Datatype origin_datatype, int target_rank,
+                                          MPI_Aint target_disp, MPI_Count target_count,
+                                          MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
 OMPI_DECLSPEC  int PMPI_Get_accumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                                        void *result_addr, int result_count, MPI_Datatype result_datatype,
                                        int target_rank, MPI_Aint target_disp, int target_count,
@@ -3099,6 +3196,16 @@ OMPI_DECLSPEC  int PMPI_Get_accumulate_c(const void *origin_addr, MPI_Count orig
                                          void *result_addr, MPI_Count result_count, MPI_Datatype result_datatype,
                                          int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                          MPI_Datatype target_datatype, MPI_Op op, MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Get_accumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                              void *result_addr, int result_count, MPI_Datatype result_datatype,
+                                              int target_rank, MPI_Aint target_disp, int target_count,
+                                              MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                              MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Get_accumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                                void *result_addr, MPI_Count result_count, MPI_Datatype result_datatype,
+                                                int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                                MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                                MPI_Win win);
 OMPI_DECLSPEC  int PMPI_Get_library_version(char *version, int *resultlen);
 OMPI_DECLSPEC  int PMPI_Get_processor_name(char *name, int *resultlen);
 OMPI_DECLSPEC  int PMPI_Get_version(int *version, int *subversion);
@@ -3354,6 +3461,12 @@ OMPI_DECLSPEC  int PMPI_Put(const void *origin_addr, int origin_count, MPI_Datat
 OMPI_DECLSPEC  int PMPI_Put_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                               int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                               MPI_Datatype target_datatype, MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Put_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                        int target_rank, MPI_Aint target_disp, int target_count,
+                                        MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
+OMPI_DECLSPEC  int PMPI_Put_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                          int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                          MPI_Datatype target_datatype, int notification_idx, MPI_Win win);
 OMPI_DECLSPEC  int PMPI_Query_thread(int *provided);
 OMPI_DECLSPEC  int PMPI_Raccumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                                     int target_rank, MPI_Aint target_disp, int target_count,
@@ -3361,6 +3474,14 @@ OMPI_DECLSPEC  int PMPI_Raccumulate(const void *origin_addr, int origin_count, M
 OMPI_DECLSPEC  int PMPI_Raccumulate_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                                       int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                       MPI_Datatype target_datatype, MPI_Op op, MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Raccumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                           int target_rank, MPI_Aint target_disp, int target_count,
+                                           MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                           MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Raccumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                             int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                             MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                             MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int PMPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int source,
                                   int tag, MPI_Comm comm, MPI_Request *request);
 OMPI_DECLSPEC  int PMPI_Recv_init_c(void *buf, MPI_Count count, MPI_Datatype datatype, int source,
@@ -3439,6 +3560,14 @@ OMPI_DECLSPEC  int PMPI_Rget(void *origin_addr, int origin_count, MPI_Datatype o
 OMPI_DECLSPEC  int PMPI_Rget_c(void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                                int target_rank, MPI_Aint target_disp, MPI_Count target_count, MPI_Datatype target_datatype,
                                MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Rget_notify(void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                    int target_rank, MPI_Aint target_disp, int target_count,
+                                    MPI_Datatype target_datatype, int notification_idx,
+                                    MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Rget_notify_c(void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                      int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                      MPI_Datatype target_datatype, int notification_idx,
+                                      MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int PMPI_Rget_accumulate(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                                         void *result_addr, int result_count, MPI_Datatype result_datatype,
                                         int target_rank, MPI_Aint target_disp, int target_count,
@@ -3449,12 +3578,30 @@ OMPI_DECLSPEC  int PMPI_Rget_accumulate_c(const void *origin_addr, MPI_Count ori
                                           int target_rank, MPI_Aint target_disp, MPI_Count target_count,
                                           MPI_Datatype target_datatype, MPI_Op op,
                                           MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Rget_accumulate_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                               void *result_addr, int result_count, MPI_Datatype result_datatype,
+                                               int target_rank, MPI_Aint target_disp, int target_count,
+                                               MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                               MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Rget_accumulate_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                                 void *result_addr, MPI_Count result_count, MPI_Datatype result_datatype,
+                                                 int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                                 MPI_Datatype target_datatype, MPI_Op op, int notification_idx,
+                                                 MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int PMPI_Rput(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
                              int target_rank, MPI_Aint target_disp, int target_cout,
                              MPI_Datatype target_datatype, MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int PMPI_Rput_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
                                int target_rank, MPI_Aint target_disp, MPI_Count target_cout,
                                MPI_Datatype target_datatype, MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Rput_notify(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
+                                    int target_rank, MPI_Aint target_disp, int target_count,
+                                    MPI_Datatype target_datatype, int notification_idx,
+                                    MPI_Win win, MPI_Request *request);
+OMPI_DECLSPEC  int PMPI_Rput_notify_c(const void *origin_addr, MPI_Count origin_count, MPI_Datatype origin_datatype,
+                                      int target_rank, MPI_Aint target_disp, MPI_Count target_count,
+                                      MPI_Datatype target_datatype, int notification_idx,
+                                      MPI_Win win, MPI_Request *request);
 OMPI_DECLSPEC  int PMPI_Rsend(const void *ibuf, int count, MPI_Datatype datatype, int dest,
                               int tag, MPI_Comm comm);
 OMPI_DECLSPEC  int PMPI_Rsend_c(const void *ibuf, MPI_Count count, MPI_Datatype datatype, int dest,
@@ -3537,7 +3684,7 @@ OMPI_DECLSPEC  int PMPI_Sendrecv_replace(void * buf, int count, MPI_Datatype dat
 OMPI_DECLSPEC  int PMPI_Sendrecv_replace_c(void * buf, MPI_Count count, MPI_Datatype datatype,
                                            int dest, int sendtag, int source, int recvtag,
                                            MPI_Comm comm, MPI_Status *status);
-OMPI_DECLSPEC  MPI_Fint PMPI_Session_c2f (const MPI_Session session);
+OMPI_DECLSPEC  MPI_Fint PMPI_Session_c2f (MPI_Session session);
 OMPI_DECLSPEC  int PMPI_Session_attach_buffer(MPI_Session session, void *buffer, int size);
 OMPI_DECLSPEC  int PMPI_Session_attach_buffer_c(MPI_Session session, void *buffer, MPI_Count size);
 OMPI_DECLSPEC  int PMPI_Session_call_errhandler(MPI_Session session, int errorcode);
@@ -3689,7 +3836,7 @@ OMPI_DECLSPEC  int PMPI_Type_get_envelope(MPI_Datatype type, int *num_integers,
                                           int *num_addresses, int *num_datatypes,
                                           int *combiner);
 OMPI_DECLSPEC  int PMPI_Type_get_envelope_c(MPI_Datatype type, MPI_Count *num_integers,
-                                          MPI_Count *num_addresses, MPI_Count *num_large_counts, 
+                                          MPI_Count *num_addresses, MPI_Count *num_large_counts,
         				  MPI_Count *num_datatypes, int *combiner);
 OMPI_DECLSPEC  int PMPI_Type_get_extent(MPI_Datatype type, MPI_Aint *lb,
                                         MPI_Aint *extent);
@@ -3778,6 +3925,10 @@ OMPI_DECLSPEC  int PMPI_Win_get_errhandler(MPI_Win win, MPI_Errhandler *errhandl
 OMPI_DECLSPEC  int PMPI_Win_get_group(MPI_Win win, MPI_Group *group);
 OMPI_DECLSPEC  int PMPI_Win_get_info(MPI_Win win, MPI_Info *info_used);
 OMPI_DECLSPEC  int PMPI_Win_get_name(MPI_Win win, char *win_name, int *resultlen);
+OMPI_DECLSPEC  int PMPI_Win_get_notify_value(MPI_Win win, int notification_idx, MPI_Count *value);
+OMPI_DECLSPEC  int PMPI_Win_reset_notify_value(MPI_Win win, int notification_idx, MPI_Count *value);
+OMPI_DECLSPEC  int PMPI_Win_get_num_notify(MPI_Win win, int target_rank, int *num_notifications);
+OMPI_DECLSPEC  int PMPI_Win_set_num_notify(MPI_Win win, MPI_Info info, int num_notifications);
 OMPI_DECLSPEC  int PMPI_Win_lock(int lock_type, int rank, int mpi_assert, MPI_Win win);
 OMPI_DECLSPEC  int PMPI_Win_lock_all(int mpi_assert, MPI_Win win);
 OMPI_DECLSPEC  int PMPI_Win_post(MPI_Group group, int mpi_assert, MPI_Win win);
diff --git a/ompi/include/mpif-values.py b/ompi/include/mpif-values.py
index 53159d5d8dd..bfaca964abf 100755
--- a/ompi/include/mpif-values.py
+++ b/ompi/include/mpif-values.py
@@ -11,6 +11,7 @@
 # Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
 # Copyright (c) 2025      Triad National Security, LLC. All rights
 #                         reserved.
+# Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -194,6 +195,9 @@
     'MPI_WIN_CREATE_FLAVOR': 10,
     'MPI_WIN_MODEL': 11,
     'MPI_FT': 12,
+    'MPI_WIN_NOTIFICATION_NUM_SB': 13,
+    'MPI_WIN_NOTIFICATION_NUM_UB': 14,
+    'MPI_WIN_NOTIFICATION_VALUE_UB': 15,
     'MPI_WIN_FLAVOR_CREATE': 1,
     'MPI_WIN_FLAVOR_ALLOCATE': 2,
     'MPI_WIN_FLAVOR_DYNAMIC': 3,
@@ -301,6 +305,9 @@
     'MPI_ERR_SESSION': 78,
     'MPI_ERR_VALUE_TOO_LARGE': 79,
     'MPI_ERR_ERRHANDLER': 80,
+    'MPI_T_ERR_NOT_ACCESSIBLE': 81,
+    'MPI_T_ERR_NOT_SUPPORTED': 82,
+    'MPI_ERR_RMA_NOTIFICATION': 83,
     'MPI_ERR_LASTCODE': 92,
     'MPI_IDENT': 0,
     'MPI_CONGRUENT': 1,
@@ -342,6 +349,7 @@
     'MPI_COMM_TYPE_HW_UNGUIDED': 12,
     'MPI_COMM_TYPE_HW_GUIDED': 13,
     'MPI_COMM_TYPE_RESOURCE_GUIDED': 14,
+    'OMPI_COMM_TYPE_NVLINK': 15,
 }
 
 # IO Constants
diff --git a/ompi/instance/instance.c b/ompi/instance/instance.c
index 6d50d32ffb2..3b93abcf82f 100644
--- a/ompi/instance/instance.c
+++ b/ompi/instance/instance.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2018-2025 Triad National Security, LLC. All rights
+ * Copyright (c) 2018-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2022      The University of Tennessee and The University
@@ -9,6 +9,7 @@
  * Copyright (c) 2023      Jeffrey M. Squyres.  All rights reserved.
  * Copyright (c) 2024      NVIDIA Corporation.  All rights reserved.
  * Copyright (c) 2026      Nanook Consulting  All rights reserved.
+ * Copyright (c) 2026      BULL S.A.S.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -108,8 +109,9 @@ static opal_finalize_domain_t ompi_instance_common_domain;
 static void ompi_instance_construct (ompi_instance_t *instance)
 {
     instance->i_f_to_c_index = opal_pointer_array_add (&ompi_instance_f_to_c_table, instance);
+    instance->i_name = (char*) malloc (MPI_MAX_OBJECT_NAME);
     instance->i_name[0] = '\0';
-    instance->i_flags = 0;
+    instance->i_flags   = 0;
     instance->i_keyhash = NULL;
     OBJ_CONSTRUCT(&instance->s_lock, opal_mutex_t);
     instance->errhandler_type = OMPI_ERRHANDLER_TYPE_INSTANCE;
@@ -118,6 +120,8 @@ static void ompi_instance_construct (ompi_instance_t *instance)
 
 static void ompi_instance_destruct(ompi_instance_t *instance)
 {
+    free(instance->i_name);
+    instance->i_name = NULL;
     OBJ_DESTRUCT(&instance->s_lock);
 }
 
@@ -421,6 +425,14 @@ static int ompi_mpi_instance_init_common (int argc, char **argv)
         return ompi_instance_print_error ("ompi_mpi_init: ompi_rte_init failed", ret);
     }
 
+    /* ompi_rte_init() called opal_init(), which set the current finalize
+     * domain to its own.  Restore ours, or every cleanup we register from here
+     * on lands in OPAL's domain and runs from inside opal_finalize() -- after
+     * we have already torn the RTE down, and before we close the frameworks
+     * whose components those cleanups touch.
+     */
+    opal_finalize_set_domain (&ompi_instance_common_domain);
+
     /* open the ompi hook framework */
     for (int i = 0 ; ompi_framework_dependencies[i] ; ++i) {
         ret = mca_base_framework_open (ompi_framework_dependencies[i], 0);
@@ -844,6 +856,24 @@ static int ompi_mpi_instance_init_common (int argc, char **argv)
     return OMPI_SUCCESS;
 }
 
+/* MPI-5.0 sec 11.3.1: the Session's actually-provided thread level is fixed
+ * for the Session's lifetime, so always re-assert it regardless of later
+ * info changes. The returned strings are string literals (static storage),
+ * which opal_info_set() copies, so no allocation/lifetime management is
+ * needed. The callback signature matches opal_key_interest_callback_t. */
+static const char *ompi_info_thread_level_cb (opal_infosubscriber_t *obj,
+                                               const char *key, const char *value)
+{
+    ompi_instance_t *instance = (ompi_instance_t *) obj;
+    switch (instance->i_thread_level) {
+    case MPI_THREAD_FUNNELED:   return "MPI_THREAD_FUNNELED";
+    case MPI_THREAD_SERIALIZED: return "MPI_THREAD_SERIALIZED";
+    case MPI_THREAD_MULTIPLE:   return "MPI_THREAD_MULTIPLE";
+    case MPI_THREAD_SINGLE:
+    default:                    return "MPI_THREAD_SINGLE";
+    }
+}
+
 int ompi_mpi_instance_init (int ts_level,  opal_info_t *info, ompi_errhandler_t *errhandler, ompi_instance_t **instance, int argc, char **argv)
 {
     ompi_instance_t *new_instance;
@@ -884,13 +914,34 @@ int ompi_mpi_instance_init (int ts_level,  opal_info_t *info, ompi_errhandler_t
     new_instance->error_handler = errhandler;
     OBJ_RETAIN(new_instance->error_handler);
 
+    /* Store the actually-provided thread level so it can be published via
+     * MPI_Session_get_info (MPI-5.0 sec 11.3.1 / sec 11.3.3). */
+    new_instance->i_thread_level = ts_level;
+
+
+    /* Ensure s_info is allocated before subscribing pre-defined keys. */
+    if (NULL == new_instance->super.s_info) {
+        new_instance->super.s_info = OBJ_NEW(opal_info_t);
+    }
+
     /* Copy info if there is one. */
+    if (OPAL_UNLIKELY(NULL != info)) {
+        opal_info_dup(info, &new_instance->super.s_info);
+    }
+
+    /* MPI-5.0 sec 11.3.1 / sec 11.3.3: the actually-provided thread support
+     * level must be retrievable via MPI_Session_get_info. Publish it into the
+     * Session info so it round-trips through session_get_info(). */
+    opal_infosubscribe_subscribe (&new_instance->super, "thread_level",
+                                  ompi_info_thread_level_cb (&new_instance->super,
+                                                             "thread_level", NULL),
+                                  ompi_info_thread_level_cb);
+
     if (OPAL_UNLIKELY(NULL != info)) {
         opal_cstring_t *memkind_requested;
         ompi_info_memkind_assert_type type;
         int flag;
-        
-        new_instance->super.s_info = OBJ_NEW(opal_info_t);
+
         opal_info_get(info, "mpi_memory_alloc_kinds", &memkind_requested, &flag);
         if (1 == flag) {
             char *memkind_provided;
@@ -900,10 +951,6 @@ int ompi_mpi_instance_init (int ts_level,  opal_info_t *info, ompi_errhandler_t
             free (memkind_provided);
             OBJ_RELEASE(memkind_requested);
         }
-
-        if (info) {
-            opal_info_dup(info, &new_instance->super.s_info);
-        }
     }
 
     *instance = new_instance;
@@ -972,13 +1019,13 @@ static int ompi_mpi_instance_finalize_common (void)
         ompi_ulfm_pmix_err_handler = 0;
     }
 
-    /* Leave the RTE */
-    if (OMPI_SUCCESS != (ret = ompi_rte_finalize())) {
-        return ret;
-    }
-
-    ompi_rte_initialized = false;
-
+    /* Close our frameworks before leaving the RTE.  ompi_rte_finalize() calls
+     * opal_finalize(), and the BML opens the *OPAL* BTL framework on our
+     * behalf -- so leaving these open across ompi_rte_finalize() means
+     * finalizing OPAL while an OPAL framework is still open, and its
+     * components (e.g., the TCP BTL) still have events registered on
+     * opal_sync_event_base.
+     */
     for (int i = 0 ; ompi_lazy_frameworks[i] ; ++i) {
         if (0 < ompi_lazy_frameworks[i]->framework_refcnt) {
             /* May have been "opened" multiple times. We want it closed now! */
@@ -1003,6 +1050,13 @@ static int ompi_mpi_instance_finalize_common (void)
         }
     }
 
+    /* Leave the RTE */
+    if (OMPI_SUCCESS != (ret = ompi_rte_finalize())) {
+        return ret;
+    }
+
+    ompi_rte_initialized = false;
+
     ompi_proc_finalize();
 
     ompi_mpi_instance_release ();
diff --git a/ompi/instance/instance.h b/ompi/instance/instance.h
index ce5fb25919c..fc79dfe1b15 100644
--- a/ompi/instance/instance.h
+++ b/ompi/instance/instance.h
@@ -29,7 +29,7 @@ struct ompi_instance_t {
     opal_infosubscriber_t  super;
     opal_mutex_t           s_lock;
     int                    i_thread_level;
-    char                   i_name[MPI_MAX_OBJECT_NAME];
+    char                  *i_name;
     uint32_t               i_flags;
 
     /* Attributes */
diff --git a/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter.c b/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter.c
index 222e9401910..9c4bfeba69c 100644
--- a/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter.c
+++ b/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter.c
@@ -43,7 +43,7 @@ mca_coll_accelerator_reduce_scatter(const void *sbuf, void *rbuf, ompi_count_arr
     ptrdiff_t gap;
     char *rbuf1 = NULL, *sbuf1 = NULL, *rbuf2 = NULL;
     int sbuf_dev, rbuf_dev;
-    size_t sbufsize, rbufsize, elemsize;
+    size_t sbufsize, rbufsize, rbuf_in_size, elemsize;
     int rc, i;
     int comm_size = ompi_comm_size(comm);
     int total_count = 0;
@@ -73,13 +73,17 @@ mca_coll_accelerator_reduce_scatter(const void *sbuf, void *rbuf, ompi_count_arr
         goto exit;
     }
     rbufsize = elemsize * ompi_count_array_get(rcounts, ompi_comm_rank(comm));
+    /* With MPI_IN_PLACE the input lives entirely in rbuf and spans the full
+     * sum(rcounts); stage that span device->host so the fallback collective
+     * doesn't read past the host allocation. */
+    rbuf_in_size = (MPI_IN_PLACE == sbuf) ? sbufsize : rbufsize;
     if (0 < rc) {
-        rbuf1 = (char*)malloc(rbufsize);
+        rbuf1 = (char*)malloc(rbuf_in_size);
         if (NULL == rbuf1) {
             rc = OMPI_ERR_OUT_OF_RESOURCE;
 	    goto exit;
         }
-        mca_coll_accelerator_memcpy(rbuf1, MCA_ACCELERATOR_NO_DEVICE_ID, rbuf, rbuf_dev, rbufsize,
+        mca_coll_accelerator_memcpy(rbuf1, MCA_ACCELERATOR_NO_DEVICE_ID, rbuf, rbuf_dev, rbuf_in_size,
                                     MCA_ACCELERATOR_TRANSFER_DTOH);
         rbuf2 = rbuf; /* save away original buffer */
         rbuf = rbuf1 - gap;
diff --git a/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter_block.c b/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter_block.c
index 5f0fd61914f..7df1881ce00 100644
--- a/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter_block.c
+++ b/ompi/mca/coll/accelerator/coll_accelerator_reduce_scatter_block.c
@@ -43,12 +43,16 @@ mca_coll_accelerator_reduce_scatter_block(const void *sbuf, void *rbuf, size_t r
     ptrdiff_t gap;
     char *rbuf1 = NULL, *sbuf1 = NULL, *rbuf2 = NULL;
     int sbuf_dev, rbuf_dev;
-    size_t sbufsize, rbufsize;
+    size_t sbufsize, rbufsize, rbuf_in_size;
     int rc;
 
     rbufsize = opal_datatype_span(&dtype->super, rcount, &gap);
 
     sbufsize = rbufsize * ompi_comm_size(comm);
+    /* With MPI_IN_PLACE the input lives entirely in rbuf and spans
+     * comm_size * rcount elements; stage the full span device->host so the
+     * fallback collective doesn't read past the host allocation. */
+    rbuf_in_size = (MPI_IN_PLACE == sbuf) ? sbufsize : rbufsize;
     rc = mca_coll_accelerator_check_buf((void *)sbuf, &sbuf_dev);
     if (rc < 0) {
         return rc;
@@ -67,12 +71,12 @@ mca_coll_accelerator_reduce_scatter_block(const void *sbuf, void *rbuf, size_t r
         return rc;
     }
     if (rc > 0) {
-        rbuf1 = (char*)malloc(rbufsize);
+        rbuf1 = (char*)malloc(rbuf_in_size);
         if (NULL == rbuf1) {
             if (NULL != sbuf1) free(sbuf1);
             return OMPI_ERR_OUT_OF_RESOURCE;
         }
-        mca_coll_accelerator_memcpy(rbuf1, MCA_ACCELERATOR_NO_DEVICE_ID, rbuf, rbuf_dev, rbufsize,
+        mca_coll_accelerator_memcpy(rbuf1, MCA_ACCELERATOR_NO_DEVICE_ID, rbuf, rbuf_dev, rbuf_in_size,
                                     MCA_ACCELERATOR_TRANSFER_DTOH);
         rbuf2 = rbuf; /* save away original buffer */
         rbuf = rbuf1 - gap;
diff --git a/ompi/mca/coll/acoll/coll_acoll.h b/ompi/mca/coll/acoll/coll_acoll.h
index fe1b44081e1..e5528aa62c4 100644
--- a/ompi/mca/coll/acoll/coll_acoll.h
+++ b/ompi/mca/coll/acoll/coll_acoll.h
@@ -1,6 +1,7 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
  * Copyright (c) 2024 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026        NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -265,4 +266,24 @@ struct mca_coll_acoll_module_t {
 typedef struct mca_coll_acoll_module_t mca_coll_acoll_module_t;
 OMPI_DECLSPEC OBJ_CLASS_DECLARATION(mca_coll_acoll_module_t);
 
+/**
+ * Free a sub-communicator that was OBJ_RETAIN'd by the module.
+ * Releases the ownership reference safely: ompi_comm_free handles
+ * attribute cleanup + one OBJ_RELEASE; if the sub-comm survives
+ * (ownership ref still held), ompi_comm_lookup finds it and
+ * OBJ_RELEASE drops it to zero.
+ */
+static inline void coll_acoll_subcomm_free(ompi_communicator_t **comm)
+{
+    if (NULL != *comm) {
+        int cid = (*comm)->c_index;
+        ompi_comm_free(comm);
+        ompi_communicator_t *tmp = ompi_comm_lookup(cid);
+        if (NULL != tmp) {
+            OBJ_RELEASE(tmp);
+        }
+        *comm = NULL;
+    }
+}
+
 #endif /* MCA_COLL_ACOLL_EXPORT_H */
diff --git a/ompi/mca/coll/acoll/coll_acoll_component.c b/ompi/mca/coll/acoll/coll_acoll_component.c
index d364058990c..a318a8c14ef 100644
--- a/ompi/mca/coll/acoll/coll_acoll_component.c
+++ b/ompi/mca/coll/acoll/coll_acoll_component.c
@@ -1,6 +1,7 @@
 /* -*- Mode: C; c-acoll-offset:4 ; indent-tabs-mode:nil -*- */
 /*
  * Copyright (c) 2024 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026        NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -322,48 +323,22 @@ static void mca_coll_acoll_module_destruct(mca_coll_acoll_module_t *module)
             }
         }
 
-        if (subc->local_comm != NULL) {
-            ompi_comm_free(&(subc->local_comm));
-            subc->local_comm = NULL;
-        }
-
-        if (subc->local_r_comm != NULL) {
-            ompi_comm_free(&(subc->local_r_comm));
-            subc->local_r_comm = NULL;
-        }
-
-        if (subc->leader_comm != NULL) {
-            ompi_comm_free(&(subc->leader_comm));
-            subc->leader_comm = NULL;
-        }
-
-        if (subc->subgrp_comm != NULL) {
-            ompi_comm_free(&(subc->subgrp_comm));
-            subc->subgrp_comm = NULL;
-        }
-        if (subc->socket_comm != NULL) {
-            ompi_comm_free(&(subc->socket_comm));
-            subc->socket_comm = NULL;
-        }
-
-        if (subc->socket_ldr_comm != NULL) {
-            ompi_comm_free(&(subc->socket_ldr_comm));
-            subc->socket_ldr_comm = NULL;
-        }
+        coll_acoll_subcomm_free(&(subc->local_comm));
+        coll_acoll_subcomm_free(&(subc->local_r_comm));
+        coll_acoll_subcomm_free(&(subc->leader_comm));
+        coll_acoll_subcomm_free(&(subc->subgrp_comm));
+        coll_acoll_subcomm_free(&(subc->socket_comm));
+        coll_acoll_subcomm_free(&(subc->socket_ldr_comm));
+        coll_acoll_subcomm_free(&(subc->numa_comm));
+        coll_acoll_subcomm_free(&(subc->numa_comm_ldrs));
         for (int k = 0; k < MCA_COLL_ACOLL_NUM_BASE_LYRS; k++) {
             for (int j = 0; j < MCA_COLL_ACOLL_NUM_LAYERS; j++) {
-                if (subc->base_comm[k][j] != NULL) {
-                    ompi_comm_free(&(subc->base_comm[k][j]));
-                    subc->base_comm[k][j] = NULL;
-                }
+                coll_acoll_subcomm_free(&(subc->base_comm[k][j]));
             }
         }
 
         for (int k = 0; k < MCA_COLL_ACOLL_SPLIT_FACTOR_LIST_LEN; ++k) {
-            if (subc->split_comm[k] != NULL) {
-                ompi_comm_free(&(subc->split_comm[k]));
-                subc->split_comm[k] = NULL;
-            }
+            coll_acoll_subcomm_free(&(subc->split_comm[k]));
         }
         subc->initialized = 0;
         free(subc);
diff --git a/ompi/mca/coll/acoll/coll_acoll_utils.h b/ompi/mca/coll/acoll/coll_acoll_utils.h
index e15d38b7aaa..41d02381b5f 100644
--- a/ompi/mca/coll/acoll/coll_acoll_utils.h
+++ b/ompi/mca/coll/acoll/coll_acoll_utils.h
@@ -1,6 +1,7 @@
 /* -*- Mode: C; indent-tabs-mode:nil -*- */
 /*
  * Copyright (c) 2024 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026        NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -286,6 +287,7 @@ static inline int mca_coll_acoll_create_base_comm(ompi_communicator_t **parent_c
         err = ompi_comm_split(parent_comm[i], color, rank[i], &subc->base_comm[base_lyr][i], false);
         if (MPI_SUCCESS != err)
             return err;
+        OBJ_RETAIN(subc->base_comm[base_lyr][i]);
 
         /* Find out local rank of root in base comm */
         err = comm_grp_ranks_local(parent_comm[i], subc->base_comm[base_lyr][i], &is_root_node,
@@ -448,12 +450,14 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
         if (MPI_SUCCESS != err) {
             return err;
         }
+        OBJ_RETAIN(subc->local_comm);
         /* Create socket-level subcommunicator */
         err = ompi_comm_split_type(comm, OMPI_COMM_TYPE_SOCKET, 0, &comm_info,
                                    &(subc->socket_comm));
         if (MPI_SUCCESS != err) {
             return err;
         }
+        OBJ_RETAIN(subc->socket_comm);
         OBJ_DESTRUCT(&comm_info);
         OBJ_CONSTRUCT(&comm_info, opal_info_t);
         opal_info_set(&comm_info, "ompi_comm_coll_preference", "libnbc,basic,^acoll");
@@ -463,10 +467,12 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
         if (MPI_SUCCESS != err) {
             return err;
         }
+        OBJ_RETAIN(subc->subgrp_comm);
         err = ompi_comm_split_type(comm, OMPI_COMM_TYPE_NUMA, 0, &comm_info, &(subc->numa_comm));
         if (MPI_SUCCESS != err) {
             return err;
         }
+        OBJ_RETAIN(subc->numa_comm);
         subc->subgrp_size = ompi_comm_size(subc->subgrp_comm);
         OBJ_DESTRUCT(&comm_info);
 
@@ -514,18 +520,14 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
 
         if (subc->initialized) {
             if (subc->num_nodes > 1) {
-                ompi_comm_free(&(subc->leader_comm));
-                subc->leader_comm = NULL;
+                coll_acoll_subcomm_free(&(subc->leader_comm));
             }
-            ompi_comm_free(&(subc->socket_ldr_comm));
-            subc->socket_ldr_comm = NULL;
+            coll_acoll_subcomm_free(&(subc->socket_ldr_comm));
         }
         for (int i = 0; i < MCA_COLL_ACOLL_NUM_LAYERS; i++) {
             if (subc->initialized) {
-                ompi_comm_free(&(subc->base_comm[MCA_COLL_ACOLL_L3CACHE][i]));
-                subc->base_comm[MCA_COLL_ACOLL_L3CACHE][i] = NULL;
-                ompi_comm_free(&(subc->base_comm[MCA_COLL_ACOLL_NUMA][i]));
-                subc->base_comm[MCA_COLL_ACOLL_NUMA][i] = NULL;
+                coll_acoll_subcomm_free(&(subc->base_comm[MCA_COLL_ACOLL_L3CACHE][i]));
+                coll_acoll_subcomm_free(&(subc->base_comm[MCA_COLL_ACOLL_NUMA][i]));
             }
             subc->base_root[MCA_COLL_ACOLL_L3CACHE][i] = -1;
             subc->base_root[MCA_COLL_ACOLL_NUMA][i] = -1;
@@ -577,6 +579,7 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
         if (MPI_SUCCESS != err) {
             return err;
         }
+        OBJ_RETAIN(subc->leader_comm);
 
         /* Find out local rank of root in leader comm */
         err = comm_grp_ranks_local(comm, subc->leader_comm, &is_root_node, &subc->outer_grp_root,
@@ -596,6 +599,7 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
         err = ompi_comm_split(comm, color, rank, &subc->socket_ldr_comm, false);
         if (MPI_SUCCESS != err)
             return err;
+        OBJ_RETAIN(subc->socket_ldr_comm);
 
         /* Find out local rank of root in socket leader comm */
         err = comm_grp_ranks_local(comm, subc->socket_ldr_comm, &is_root_socket,
@@ -661,6 +665,7 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
         if (MPI_SUCCESS != err) {
             return err;
         }
+        OBJ_RETAIN(subc->socket_ldr_comm);
 
         /* Find out local rank of root in socket leader comm */
         err = comm_grp_ranks_local(comm, subc->socket_ldr_comm, &is_root_socket,
@@ -693,6 +698,10 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
         numa_rank = ompi_comm_rank(subc->numa_comm);
         color = (0 == numa_rank) ? 0 : 1;
         err = ompi_comm_split(subc->local_comm, color, rank, &subc->numa_comm_ldrs, false);
+        if (MPI_SUCCESS != err) {
+            return err;
+        }
+        OBJ_RETAIN(subc->numa_comm_ldrs);
 
         /* Find out local rank of root in numa comm */
         err = comm_grp_ranks_local(comm, subc->numa_comm, &subc->is_root_numa, &subc->numa_root,
@@ -745,6 +754,7 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
             if (MPI_SUCCESS != err) {
                 return err;
             }
+            OBJ_RETAIN(subc->local_r_comm);
         }
 
         err = mca_coll_acoll_derive_r2r_latency(comm, subc, acoll_module);
@@ -770,6 +780,7 @@ static inline int mca_coll_acoll_comm_split_init(ompi_communicator_t *comm,
             if (MPI_SUCCESS != err) {
                 return err;
             }
+            OBJ_RETAIN(subc->split_comm[ii]);
         }
 
         subc->derived_node_size = (size + subc->num_nodes - 1) / subc->num_nodes;
diff --git a/ompi/mca/coll/base/coll_base_allgatherv.c b/ompi/mca/coll/base/coll_base_allgatherv.c
index 337e09f7c77..9d86772181f 100644
--- a/ompi/mca/coll/base/coll_base_allgatherv.c
+++ b/ompi/mca/coll/base/coll_base_allgatherv.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2015-2016 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2017      IBM Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -101,7 +102,8 @@ int ompi_coll_base_allgatherv_intra_bruck(const void *sbuf, size_t scount,
                                            mca_coll_base_module_t *module)
 {
     int line = -1, err = 0, rank, size, sendto, recvfrom, distance, blockcount, i;
-    int *new_rcounts = NULL, *new_rdispls = NULL, *new_scounts = NULL, *new_sdispls = NULL;
+    size_t *new_rcounts = NULL, *new_scounts = NULL;
+    ptrdiff_t *new_rdispls = NULL, *new_sdispls = NULL;
     ptrdiff_t rlb, rext;
     char *tmpsend = NULL, *tmprecv = NULL;
     struct ompi_datatype_t *new_rdtype, *new_sdtype;
@@ -142,11 +144,11 @@ int ompi_coll_base_allgatherv_intra_bruck(const void *sbuf, size_t scount,
     blockcount = 1;
     tmpsend = (char*) rbuf;
 
-    new_rcounts = (int*) calloc(4*size, sizeof(int));
+    new_rcounts = (size_t*) calloc(4*size, sizeof(size_t));
     if (NULL == new_rcounts) { err = -1; line = __LINE__; goto err_hndl; }
-    new_rdispls = new_rcounts + size;
-    new_scounts = new_rdispls + size;
-    new_sdispls = new_scounts + size;
+    new_scounts = new_rcounts + size;
+    new_rdispls = (ptrdiff_t*) (new_scounts + size);
+    new_sdispls = new_rdispls + size;
 
     for (distance = 1; distance < size; distance<<=1) {
 
@@ -168,10 +170,12 @@ int ompi_coll_base_allgatherv_intra_bruck(const void *sbuf, size_t scount,
             new_rcounts[i] = ompi_count_array_get(rcounts, tmp_rrank);
             new_rdispls[i] = ompi_disp_array_get(rdispls, tmp_rrank);
         }
-        err = ompi_datatype_create_indexed(blockcount, new_scounts, new_sdispls,
+        err = ompi_datatype_create_indexed(blockcount, OMPI_COUNT_ARRAY_CREATE(new_scounts),
+                                           OMPI_DISP_ARRAY_CREATE(new_sdispls),
                                            rdtype, &new_sdtype);
         if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
-        err = ompi_datatype_create_indexed(blockcount, new_rcounts, new_rdispls,
+        err = ompi_datatype_create_indexed(blockcount, OMPI_COUNT_ARRAY_CREATE(new_rcounts),
+                                           OMPI_DISP_ARRAY_CREATE(new_rdispls),
                                            rdtype, &new_rdtype);
 
         err = ompi_datatype_commit(&new_sdtype);
@@ -513,7 +517,8 @@ ompi_coll_base_allgatherv_intra_neighborexchange(const void *sbuf, size_t scount
     int neighbor[2], offset_at_step[2], recv_data_from[2], send_data_from;
     size_t new_scounts[2], new_rcounts[2];
     ptrdiff_t new_sdispls[2], new_rdispls[2];
-    int tmp_new_scounts[2], tmp_new_rcounts[2], tmp_new_sdispls[2], tmp_new_rdispls[2];
+    size_t tmp_new_scounts[2], tmp_new_rcounts[2];
+    ptrdiff_t tmp_new_sdispls[2], tmp_new_rdispls[2];
     ptrdiff_t rlb, rext;
     char *tmpsend = NULL, *tmprecv = NULL;
     struct ompi_datatype_t  *new_rdtype, *new_sdtype;
@@ -611,7 +616,8 @@ ompi_coll_base_allgatherv_intra_neighborexchange(const void *sbuf, size_t scount
         tmp_new_scounts[1] = new_scounts[1];
         tmp_new_sdispls[0] = new_sdispls[0];
         tmp_new_sdispls[1] = new_sdispls[1];
-        err = ompi_datatype_create_indexed(2, tmp_new_scounts, tmp_new_sdispls, rdtype,
+        err = ompi_datatype_create_indexed(2, OMPI_COUNT_ARRAY_CREATE(tmp_new_scounts),
+                                           OMPI_DISP_ARRAY_CREATE(tmp_new_sdispls), rdtype,
                                            &new_sdtype);
         if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
         err = ompi_datatype_commit(&new_sdtype);
@@ -626,7 +632,8 @@ ompi_coll_base_allgatherv_intra_neighborexchange(const void *sbuf, size_t scount
         tmp_new_rcounts[1] = new_rcounts[1];
         tmp_new_rdispls[0] = new_rdispls[0];
         tmp_new_rdispls[1] = new_rdispls[1];
-        err = ompi_datatype_create_indexed(2, tmp_new_rcounts, tmp_new_rdispls, rdtype,
+        err = ompi_datatype_create_indexed(2, OMPI_COUNT_ARRAY_CREATE(tmp_new_rcounts),
+                                           OMPI_DISP_ARRAY_CREATE(tmp_new_rdispls), rdtype,
                                            &new_rdtype);
         if (MPI_SUCCESS != err) { line = __LINE__; goto err_hndl; }
         err = ompi_datatype_commit(&new_rdtype);
@@ -757,7 +764,6 @@ ompi_coll_base_allgatherv_intra_basic_default(const void *sbuf, size_t scount,
     MPI_Aint extent, lb;
     char *send_buf = NULL;
     struct ompi_datatype_t *newtype, *send_type;
-    int *tmp_rcounts, *tmp_disps;
 
     size = ompi_comm_size(comm);
     rank = ompi_comm_rank(comm);
@@ -801,22 +807,8 @@ ompi_coll_base_allgatherv_intra_basic_default(const void *sbuf, size_t scount,
      * datatype.
      */
 
-    /* TODO:BIGCOUNT: Remove temporaries once ompi_datatype interface is updated */
-    tmp_rcounts = malloc(size * sizeof(int));
-    if (NULL == tmp_rcounts) {
-        return OMPI_ERR_OUT_OF_RESOURCE;
-    }
-    tmp_disps = malloc(size * sizeof(int));
-    if (NULL == tmp_disps) {
-        return OMPI_ERR_OUT_OF_RESOURCE;
-    }
-    for (int i = 0; i < size; i++) {
-        tmp_rcounts[i] = ompi_count_array_get(rcounts, i);
-        tmp_disps[i] = ompi_disp_array_get(disps, i);
-    }
-    err = ompi_datatype_create_indexed(size,tmp_rcounts,tmp_disps,rdtype,&newtype);
-    free(tmp_rcounts);
-    free(tmp_disps);
+    err = ompi_datatype_create_indexed(size, rcounts, disps,
+                                       rdtype, &newtype);
     if (MPI_SUCCESS != err) {
         return err;
     }
diff --git a/ompi/mca/coll/base/coll_base_reduce_scatter_block.c b/ompi/mca/coll/base/coll_base_reduce_scatter_block.c
index f72469d1a00..ca4a6989bec 100644
--- a/ompi/mca/coll/base/coll_base_reduce_scatter_block.c
+++ b/ompi/mca/coll/base/coll_base_reduce_scatter_block.c
@@ -19,6 +19,7 @@
  *                         and Information Sciences. All rights reserved.
  * Copyright (c) 2022      IBM Corporation.  All rights reserved.
  * Copyright (c) 2023      Jeffrey M. Squyres.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -202,7 +203,8 @@ ompi_coll_base_reduce_scatter_block_intra_recursivedoubling(
     struct ompi_datatype_t *dtypesend = NULL, *dtyperecv = NULL;
     char *tmprecv_raw = NULL, *tmpbuf_raw = NULL, *tmprecv, *tmpbuf;
     ptrdiff_t span, gap, totalcount, extent;
-    int blocklens[2], displs[2];
+    size_t blocklens[2];
+    ptrdiff_t displs[2];
     int err = MPI_SUCCESS;
     int comm_size = ompi_comm_size(comm);
     int rank = ompi_comm_rank(comm);
@@ -270,7 +272,8 @@ ompi_coll_base_reduce_scatter_block_intra_recursivedoubling(
                        rcount * (comm_size - cur_tree_root - mask) : 0;
         displs[0] = 0;
         displs[1] = comm_size * rcount - blocklens[1];
-        err = ompi_datatype_create_indexed(2, blocklens, displs, dtype, &dtypesend);
+        err = ompi_datatype_create_indexed(2, OMPI_COUNT_ARRAY_CREATE(blocklens),
+                                           OMPI_DISP_ARRAY_CREATE(displs), dtype, &dtypesend);
         if (MPI_SUCCESS != err) { goto cleanup_and_return; }
         err = ompi_datatype_commit(&dtypesend);
         if (MPI_SUCCESS != err) { goto cleanup_and_return; }
@@ -281,7 +284,8 @@ ompi_coll_base_reduce_scatter_block_intra_recursivedoubling(
                        rcount * (comm_size - remote_tree_root - mask) : 0;
         displs[0] = 0;
         displs[1] = comm_size * rcount - blocklens[1];
-        err = ompi_datatype_create_indexed(2, blocklens, displs, dtype, &dtyperecv);
+        err = ompi_datatype_create_indexed(2, OMPI_COUNT_ARRAY_CREATE(blocklens),
+                                           OMPI_DISP_ARRAY_CREATE(displs), dtype, &dtyperecv);
         if (MPI_SUCCESS != err) { goto cleanup_and_return; }
         err = ompi_datatype_commit(&dtyperecv);
         if (MPI_SUCCESS != err) { goto cleanup_and_return; }
diff --git a/ompi/mca/coll/base/coll_base_util.c b/ompi/mca/coll/base/coll_base_util.c
index ba74aa01350..470a8bd4ab2 100644
--- a/ompi/mca/coll/base/coll_base_util.c
+++ b/ompi/mca/coll/base/coll_base_util.c
@@ -14,6 +14,8 @@
  * Copyright (c) 2023      Jeffrey M. Squyres.  All rights reserved.
  *
  * Copyright (c) 2024      NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  *
  * $COPYRIGHT$
  *
@@ -134,7 +136,7 @@ int ompi_rounddown(int num, int factor)
 /**
  * Release all objects and arrays stored into the nbc_request.
  * The release_arrays are temporary memory to stored the values
- * converted from Fortran, and should disappear in same time as the
+ * converted from Fortran or elsewhere, and should disappear in same time as the
  * request itself.
  */
 static void
@@ -268,6 +270,7 @@ static void release_vecs_callback(ompi_coll_base_nbc_request_t *request)
         }
         request->data.refcounted.vecs.rtypes = NULL;
     }
+    release_objs_callback(request);
 }
 
 static int complete_vecs_callback(struct ompi_request_t *req) {
@@ -346,13 +349,33 @@ int ompi_coll_base_retain_datatypes_w( ompi_request_t *req,
     return OMPI_SUCCESS;
 }
 
+int ompi_coll_base_add_release_arrays_cb(ompi_request_t *req)
+{
+    ompi_coll_base_nbc_request_t *request = (ompi_coll_base_nbc_request_t *)req;
+
+    assert(NULL != request);
+
+    if (req->req_persistent && (NULL == req->req_free)) {
+        request->cb.req_free = req->req_free;
+        req->req_free = free_objs_callback;
+    } else if(NULL == req->req_complete_cb) {
+        request->cb.req_complete_cb = req->req_complete_cb;
+        request->req_complete_cb_data = req->req_complete_cb_data;
+        req->req_complete_cb = complete_objs_callback;
+        req->req_complete_cb_data = request;
+    }
+    return OMPI_SUCCESS;
+}
+
 static void nbc_req_constructor(ompi_coll_base_nbc_request_t *req)
 {
     req->cb.req_complete_cb = NULL;
     req->req_complete_cb_data = NULL;
     req->data.refcounted.objs.objs[0] = NULL;
     req->data.refcounted.objs.objs[1] = NULL;
-    req->data.release_arrays[0] = NULL;
+    for (int i = 0; i < OMPI_REQ_NB_RELEASE_ARRAYS; i++ ) {
+        req->data.release_arrays[i] = NULL;
+    }
 }
 
 OBJ_CLASS_INSTANCE(ompi_coll_base_nbc_request_t, ompi_request_t, nbc_req_constructor, NULL);
diff --git a/ompi/mca/coll/base/coll_base_util.h b/ompi/mca/coll/base/coll_base_util.h
index 7bceaa7dcc0..3a52cdebdd8 100644
--- a/ompi/mca/coll/base/coll_base_util.h
+++ b/ompi/mca/coll/base/coll_base_util.h
@@ -12,6 +12,8 @@
  * Copyright (c) 2014-2020 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2024      NVIDIA CORPORATION. All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -95,6 +97,42 @@ ompi_coll_base_nbc_reserve_tags(ompi_communicator_t* comm, int32_t reserve)
     return tag;
 }
 
+/**
+ * Append an array to a request object to be freed upon completion
+ * of the associated operation.
+ * The request object must be of type ompi_coll_base_nbc_request_t.
+ */
+__opal_attribute_always_inline__ static inline int
+ompi_coll_base_append_array_to_release(struct ompi_request_t *req, void *array_ptr)
+{
+    int i, ret = OMPI_SUCCESS;
+    struct ompi_coll_base_nbc_request_t *request = (struct ompi_coll_base_nbc_request_t *)req;
+
+    /*
+     * important sanity check - doing steps below on a non-libnbc request can lead
+     * to difficult to debug memory corruption problems
+     */
+    assert(request->super.req_type == OMPI_REQUEST_COLL);
+
+    for(i = 0; i < OMPI_REQ_NB_RELEASE_ARRAYS; i++ ) {
+        if (NULL == request->data.release_arrays[i]) {
+            break;
+        }
+    }
+
+    if (OMPI_REQ_NB_RELEASE_ARRAYS > i) {
+        request->data.release_arrays[i] = array_ptr;
+        ++i;
+        if (OMPI_REQ_NB_RELEASE_ARRAYS > i) {
+            request->data.release_arrays[i] = NULL;
+        }
+    } else {
+        ret = OMPI_ERR_OUT_OF_RESOURCE;
+    }
+
+    return ret;
+}
+
 typedef struct ompi_coll_base_nbc_request_t ompi_coll_base_nbc_request_t;
 
 /*
@@ -188,6 +226,13 @@ int ompi_coll_base_retain_datatypes_w( ompi_request_t *request,
                                        ompi_datatype_t * const rtypes[],
                                        bool use_topo);
 
+/**
+ * If necessary, set callback to free extra memory regions
+ * set in release_arrays.  Not set if a callback is already
+ * associated with the request.
+ */
+int ompi_coll_base_add_release_arrays_cb(ompi_request_t *request);
+
 /* File reading function */
 int ompi_coll_base_file_getnext_long(FILE *fptr, int *fileline, long* val);
 int ompi_coll_base_file_getnext_size_t(FILE *fptr, int *fileline, size_t* val);
diff --git a/ompi/mca/coll/base/coll_tags.h b/ompi/mca/coll/base/coll_tags.h
index 5d3da7eafe5..fe9e1ce9424 100644
--- a/ompi/mca/coll/base/coll_tags.h
+++ b/ompi/mca/coll/base/coll_tags.h
@@ -61,9 +61,13 @@
 
 #define MCA_COLL_BASE_TAG_UCC                    (MCA_COLL_BASE_TAG_FT_END - 1)
 
-#define MCA_COLL_BASE_TAG_STATIC_END             (MCA_COLL_BASE_TAG_UCC - 1)
-
+/* Distributed graph construction uses PML messages before the new
+ * communicator is fully created. Keep these tags out of the nonblocking
+ * collective tag range. */
+#define MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_IN      (MCA_COLL_BASE_TAG_UCC - 1)
+#define MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_OUT     (MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_IN - 1)
 
+#define MCA_COLL_BASE_TAG_STATIC_END             (MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_OUT)
 
 #define MCA_COLL_BASE_TAG_NONBLOCKING_BASE (MCA_COLL_BASE_TAG_STATIC_END - 1)
 #define MCA_COLL_BASE_TAG_NONBLOCKING_END ((-1 * INT_MAX/2) + 1)
diff --git a/ompi/mca/coll/han/coll_han.h b/ompi/mca/coll/han/coll_han.h
index 2af2ae7a2c4..01237afc9f7 100644
--- a/ompi/mca/coll/han/coll_han.h
+++ b/ompi/mca/coll/han/coll_han.h
@@ -43,6 +43,7 @@
 #include "ompi/mca/mca.h"
 #include "opal/util/output.h"
 #include "opal/mca/smsc/smsc.h"
+#include "opal/class/opal_free_list.h"
 #include "ompi/mca/coll/base/coll_base_functions.h"
 #include "coll_han_trigger.h"
 #include "ompi/mca/coll/han/coll_han_dynamic.h"
@@ -57,6 +58,68 @@
 #define COLL_HAN_LOW_MODULES 3
 #define COLL_HAN_UP_MODULES 2
 
+/**
+ * Fragment item for freelist-based buffer pool
+ * Used to provide stable buffer addresses across collective calls
+ */
+typedef struct fragment_item_s {
+    opal_free_list_item_t super;
+    void *buffer;  /* Fixed-size buffer (han_fragment_size bytes) */
+} fragment_item_t;
+OBJ_CLASS_DECLARATION(fragment_item_t);
+
+/**
+ * Large fragment item for freelist-based buffer pool.
+ * Size controlled by han_large_fragment_size MCA parameter (0 = disabled).
+ */
+typedef struct large_fragment_item_s {
+    opal_free_list_item_t super;
+    void *buffer;
+} large_fragment_item_t;
+OBJ_CLASS_DECLARATION(large_fragment_item_t);
+
+/** Source tag for tiered allocation (used by alloc/free helpers). */
+enum {
+    HAN_ALLOC_MALLOC = 0,
+    HAN_ALLOC_LARGE  = 1,
+    HAN_ALLOC_SMALL  = 2
+};
+
+/**
+ * Grow a shared scratch buffer to at least 'needed' bytes (realloc-to-HWM).
+ * Returns the buffer pointer, or NULL on allocation failure.
+ */
+static inline char *han_scratch_alloc(char **buf, size_t *buf_size, size_t needed)
+{
+    if (0 == needed) {
+        /* Return a valid non-NULL pointer for zero-size allocations,
+         * matching malloc(0) behavior that callers rely on. */
+        static char zero_len_sentinel;
+        return &zero_len_sentinel;
+    }
+    if (*buf_size < needed) {
+        char *p = realloc(*buf, needed);
+        if (NULL == p) return NULL;
+        *buf = p;
+        *buf_size = needed;
+    }
+    return *buf;
+}
+
+/**
+ * Allocate from scratch buffer (persist mode) or malloc (non-persist).
+ * Returns NULL on allocation failure.
+ */
+static inline char *han_scratch_or_malloc(char **scratch, size_t *scratch_size,
+                                          size_t needed, bool persist)
+{
+    if (persist) {
+        return han_scratch_alloc(scratch, scratch_size, needed);
+    }
+    return (char *)malloc(needed);
+}
+
+
 struct mca_coll_han_bcast_args_s {
     mca_coll_task_t *cur_task;
     ompi_communicator_t *up_comm;
@@ -115,11 +178,15 @@ struct mca_coll_han_allreduce_args_s {
 };
 typedef struct mca_coll_han_allreduce_args_s mca_coll_han_allreduce_args_t;
 
+/* Forward declaration needed by scatter and gather arg structs */
+typedef struct mca_coll_han_module_t mca_coll_han_module_t;
+
 struct mca_coll_han_scatter_args_s {
     mca_coll_task_t *cur_task;
     ompi_communicator_t *up_comm;
     ompi_communicator_t *low_comm;
     ompi_request_t *req;
+    mca_coll_han_module_t *han_module;
     void *sbuf;
     void *sbuf_inter_free;
     void *sbuf_reorder_free;
@@ -133,6 +200,8 @@ struct mca_coll_han_scatter_args_s {
     int root_low_rank;
     int w_rank;
     bool noop;
+    opal_free_list_item_t *reorder_fl_item; /* freelist item for reorder buf */
+    int reorder_fl_src;                      /* HAN_ALLOC_{MALLOC,LARGE,SMALL} */
 };
 typedef struct mca_coll_han_scatter_args_s mca_coll_han_scatter_args_t;
 
@@ -141,6 +210,7 @@ struct mca_coll_han_gather_args_s {
     ompi_communicator_t *up_comm;
     ompi_communicator_t *low_comm;
     ompi_request_t *req;
+    mca_coll_han_module_t *han_module;
     void *sbuf;
     void *sbuf_inter_free;
     void *rbuf;
@@ -174,6 +244,8 @@ struct mca_coll_han_allgather_s {
     bool noop;
     bool is_mapbycore;
     int *topo;
+    mca_coll_han_module_t *han_module;
+    opal_free_list_item_t *inter_frag;  /* Fragment for inter-node buffer */
 };
 typedef struct mca_coll_han_allgather_s mca_coll_han_allgather_t;
 
@@ -296,6 +368,13 @@ typedef struct mca_coll_han_component_t {
     opal_free_list_t pack_buffers;
     int64_t han_packbuf_max_count;
     int64_t han_packbuf_bytes;
+
+    /* Persist-buffer optimization (0 = disabled, use malloc/free) */
+    bool han_use_persist_buffers;
+
+    /* Fragment size for buffer reuse optimization (0 = disabled) */
+    size_t han_fragment_size;
+    size_t han_large_fragment_size;
 } mca_coll_han_component_t;
 
 /*
@@ -386,6 +465,50 @@ typedef struct mca_coll_han_module_t {
 
     /* Sub-communicator */
     struct ompi_communicator_t *sub_comm[NB_TOPO_LVL];
+
+    /* Fragment pool for buffer reuse (64KB items) */
+    opal_free_list_t fragment_freelist;
+    /* Large fragment pool for pipeline reorder buffers (1MB items) */
+    opal_free_list_t large_fragment_freelist;
+    /* Shared scratch buffers for all collectives (realloc-to-HWM).
+     * Since collectives don't run concurrently on the same communicator,
+     * all collectives share these two buffers. Two are needed because
+     * some collectives use two temporary buffers with overlapping lifetimes
+     * (e.g., allgather uses a gather buffer and a reorder buffer). */
+    char *scratch_buf[2];
+    size_t scratch_buf_size[2];
+
+    struct han_alltoall_cache {
+        char *bounce;
+        size_t bounce_size;
+        const void *cached_sbuf;
+        size_t cached_scount;
+        int cached_low_size;
+        char **low_bufs;
+        void **map_ctx;
+        void **gather_buf;
+        int cached_send_needs_bounce;
+        int cached_ii_push_data;
+        char *recv_buf;
+        size_t recv_buf_size;
+    } a2a_cache;
+
+    struct han_alltoallv_cache {
+        uint8_t *serial_buf;
+        size_t serial_buf_size;
+        void *gather_out;
+        void *peers;
+        void *peer_types;
+        int low_size;
+        void **send_from;
+        void **recv_to;
+        size_t *send_counts;
+        size_t *recv_counts;
+        void **send_types;
+        void **recv_types;
+        bool smsc_decided;
+        int use_smsc;
+    } a2av_cache;
 } mca_coll_han_module_t;
 OBJ_CLASS_DECLARATION(mca_coll_han_module_t);
 
@@ -564,7 +687,7 @@ ompi_coll_han_reorder_gather(const void *sbuf,
                              void *rbuf, size_t rcount,
                              struct ompi_datatype_t *rdtype,
                              struct ompi_communicator_t *comm,
-                             int * topo);
+                             const int * topo);
 
 static inline struct mca_smsc_endpoint_t *mca_coll_han_get_smsc_endpoint (struct ompi_proc_t *proc) {
     extern opal_mutex_t mca_coll_han_lock;
diff --git a/ompi/mca/coll/han/coll_han_allgather.c b/ompi/mca/coll/han/coll_han_allgather.c
index 9d3a0825f83..6d561bf12ac 100644
--- a/ompi/mca/coll/han/coll_han_allgather.c
+++ b/ompi/mca/coll/han/coll_han_allgather.c
@@ -24,10 +24,95 @@
 #include "ompi/mca/pml/pml.h"
 #include "coll_han_trigger.h"
 
+/* Minimum number of fragments before the pipeline path is used.
+ * Below this threshold the simple path avoids pipeline setup overhead. */
+#define HAN_MIN_PIPELINE_FRAGS 4
+
 static int mca_coll_han_allgather_lb_task(void *task_args);
 static int mca_coll_han_allgather_lg_task(void *task_args);
 static int mca_coll_han_allgather_uag_task(void *task_args);
 
+/**
+ * Allocate a buffer from the small fragment freelist, falling back to malloc.
+ * On return, *item is non-NULL if the buffer came from the freelist.
+ */
+static char *han_alloc_frag(opal_free_list_t *fl, size_t frag_size,
+                            size_t needed, opal_free_list_item_t **item)
+{
+    *item = NULL;
+    if (mca_coll_han_component.han_use_persist_buffers
+        && frag_size > 0 && needed <= frag_size) {
+        fragment_item_t *fi = (fragment_item_t *)opal_free_list_get(fl);
+        if (fi != NULL) {
+            *item = (opal_free_list_item_t *)fi;
+            return (char *)fi->buffer;
+        }
+    }
+    return (char *)malloc(needed);
+}
+
+/**
+ * Free a buffer: return to freelist if item is non-NULL, else free().
+ */
+static void han_free_frag(opal_free_list_t *fl, opal_free_list_item_t *item,
+                          char *buf)
+{
+    if (item != NULL) {
+        opal_free_list_return(fl, item);
+    } else {
+        free(buf);
+    }
+}
+
+/**
+ * Tiered allocation: try large freelist, then small freelist, then malloc.
+ * Sets *item and *src (1=large, 2=small, 0=malloc) for han_free_tiered().
+ */
+static char *han_alloc_tiered(opal_free_list_t *large_fl, size_t large_size,
+                              opal_free_list_t *small_fl, size_t small_size,
+                              size_t needed, opal_free_list_item_t **item,
+                              int *src)
+{
+    *item = NULL;
+    *src = HAN_ALLOC_MALLOC;
+    if (!mca_coll_han_component.han_use_persist_buffers) {
+        return (char *)malloc(needed);
+    }
+    if (large_size > 0 && needed <= large_size) {
+        large_fragment_item_t *lfi = (large_fragment_item_t *)opal_free_list_get(large_fl);
+        if (lfi != NULL) {
+            *item = (opal_free_list_item_t *)lfi;
+            *src = HAN_ALLOC_LARGE;
+            return (char *)lfi->buffer;
+        }
+    }
+    if (small_size > 0 && needed <= small_size) {
+        fragment_item_t *fi = (fragment_item_t *)opal_free_list_get(small_fl);
+        if (fi != NULL) {
+            *item = (opal_free_list_item_t *)fi;
+            *src = HAN_ALLOC_SMALL;
+            return (char *)fi->buffer;
+        }
+    }
+    return (char *)malloc(needed);
+}
+
+/**
+ * Free a tiered allocation based on src tag.
+ */
+static void han_free_tiered(opal_free_list_t *large_fl,
+                            opal_free_list_t *small_fl,
+                            opal_free_list_item_t *item, char *buf, int src)
+{
+    if (src == HAN_ALLOC_LARGE) {
+        opal_free_list_return(large_fl, item);
+    } else if (src == HAN_ALLOC_SMALL) {
+        opal_free_list_return(small_fl, item);
+    } else {
+        free(buf);
+    }
+}
+
 static inline void
 mca_coll_han_set_allgather_args(mca_coll_han_allgather_t * args,
                                 mca_coll_task_t * cur_task,
@@ -45,7 +130,8 @@ mca_coll_han_set_allgather_args(mca_coll_han_allgather_t * args,
                                 bool noop,
                                 bool is_mapbycore,
                                 int *topo,
-                                ompi_request_t * req)
+                                ompi_request_t * req,
+                                mca_coll_han_module_t *han_module)
 {
     args->cur_task = cur_task;
     args->sbuf = sbuf;
@@ -63,6 +149,8 @@ mca_coll_han_set_allgather_args(mca_coll_han_allgather_t * args,
     args->is_mapbycore = is_mapbycore;
     args->topo = topo;
     args->req = req;
+    args->han_module = han_module;
+    args->inter_frag = NULL;
 }
 
 
@@ -120,7 +208,7 @@ mca_coll_han_allgather_intra(const void *sbuf, size_t scount,
     mca_coll_han_set_allgather_args(lg_args, lg, (char *) sbuf, NULL, scount, sdtype, rbuf, rcount,
                                     rdtype, root_low_rank, up_comm, low_comm, w_rank,
                                     low_rank != root_low_rank, han_module->is_mapbycore, topo,
-                                    temp_request);
+                                    temp_request, han_module);
     /* Init and issue lg task */
     init_task(lg, mca_coll_han_allgather_lg_task, (void *) (lg_args));
     issue_task(lg);
@@ -140,19 +228,73 @@ int mca_coll_han_allgather_lg_task(void *task_args)
     OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output, "[%d] HAN Allgather:  lg\n",
                          t->w_rank));
 
-    /* If the process is one of the node leader */
     ptrdiff_t rlb, rext;
     ompi_datatype_get_extent (t->rdtype, &rlb, &rext);
     if (MPI_IN_PLACE == t->sbuf) {
         t->sdtype = t->rdtype;
         t->scount = t->rcount;
     }
+    
+    /* If the process is one of the node leaders, allocate receive buffer */
     if (!t->noop) {
         int low_size = ompi_comm_size(t->low_comm);
         ptrdiff_t rsize, rgap = 0;
+
+        /* Mapbycore in-place: gather directly into rbuf slot, skip tmp_buf */
+        if (t->is_mapbycore && mca_coll_han_component.han_use_persist_buffers) {
+            int up_rank = ompi_comm_rank(t->up_comm);
+            size_t total_count = t->rcount * low_size;
+            char *my_slot = (char *)t->rbuf
+                + (ptrdiff_t)up_rank * (ptrdiff_t)total_count * rext;
+
+            if (MPI_IN_PLACE == t->sbuf) {
+                char *my_data = ((char*)t->rbuf)
+                    + (ptrdiff_t)t->w_rank * (ptrdiff_t)t->rcount * rext;
+                ompi_datatype_copy_content_same_ddt(t->rdtype, t->rcount,
+                                                    my_slot, my_data);
+                t->low_comm->c_coll->coll_gather(MPI_IN_PLACE, t->scount, t->sdtype,
+                                                 my_slot, t->rcount, t->rdtype,
+                                                 t->root_low_rank, t->low_comm,
+                                                 t->low_comm->c_coll->coll_gather_module);
+            } else {
+                t->low_comm->c_coll->coll_gather((char *)t->sbuf, t->scount, t->sdtype,
+                                                 my_slot, t->rcount, t->rdtype,
+                                                 t->root_low_rank, t->low_comm,
+                                                 t->low_comm->c_coll->coll_gather_module);
+            }
+            t->sbuf = my_slot;
+            t->sbuf_inter_free = NULL;
+            t->inter_frag = NULL;
+
+            /* Create uag task */
+            mca_coll_task_t *uag = t->cur_task;
+            init_task(uag, mca_coll_han_allgather_uag_task, (void *) t);
+            issue_task(uag);
+            return OMPI_SUCCESS;
+        }
+
         rsize = opal_datatype_span(&t->rdtype->super, (int64_t) t->rcount * low_size, &rgap);
-        tmp_buf = (char *) malloc(rsize);
+
+        t->inter_frag = NULL;
+        if (mca_coll_han_component.han_use_persist_buffers && t->han_module != NULL) {
+            if ((size_t)rsize <= mca_coll_han_component.han_fragment_size
+                && mca_coll_han_component.han_fragment_size > 0) {
+                tmp_buf = han_alloc_frag(&t->han_module->fragment_freelist,
+                                         mca_coll_han_component.han_fragment_size,
+                                         (size_t)rsize, &t->inter_frag);
+            } else {
+                /* Too large for freelist — use shared scratch buffer */
+                tmp_buf = han_scratch_alloc(&t->han_module->scratch_buf[0],
+                                            &t->han_module->scratch_buf_size[0],
+                                            (size_t)rsize);
+                if (NULL == tmp_buf) return OMPI_ERR_OUT_OF_RESOURCE;
+            }
+        } else {
+            tmp_buf = (char *) malloc(rsize);
+            if (NULL == tmp_buf) return OMPI_ERR_OUT_OF_RESOURCE;
+        }
         tmp_rbuf = tmp_buf - rgap;
+
         if (MPI_IN_PLACE == t->sbuf) {
             tmp_send = ((char*)t->rbuf) + (ptrdiff_t)t->w_rank * (ptrdiff_t)t->rcount * rext;
             ompi_datatype_copy_content_same_ddt(t->rdtype, t->rcount, tmp_rbuf, tmp_send);
@@ -180,6 +322,12 @@ int mca_coll_han_allgather_lg_task(void *task_args)
 
     t->sbuf = tmp_rbuf;
     t->sbuf_inter_free = tmp_buf;
+    /* When using persist gather buffer, don't free it in uag_task */
+    if (mca_coll_han_component.han_use_persist_buffers
+        && t->inter_frag == NULL && t->han_module != NULL
+        && tmp_buf == t->han_module->scratch_buf[0]) {
+        t->sbuf_inter_free = NULL;
+    }
 
     /* Create uag (upper level all-gather) task */
     mca_coll_task_t *uag = t->cur_task;
@@ -207,13 +355,30 @@ int mca_coll_han_allgather_uag_task(void *task_args)
             OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
                                  "[%d]: HAN Allgather is bycore: ", t->w_rank));
             reorder_rbuf = (char *) t->rbuf;
+
+            /* When persist buffers gathered directly into rbuf, use in-place */
+            if (mca_coll_han_component.han_use_persist_buffers
+                && t->sbuf_inter_free == NULL) {
+                t->up_comm->c_coll->coll_allgather(MPI_IN_PLACE,
+                    t->scount * low_size, t->sdtype,
+                    reorder_rbuf, t->rcount * low_size, t->rdtype,
+                    t->up_comm, t->up_comm->c_coll->coll_allgather_module);
+                goto allgather_done;
+            }
         } else {
             ptrdiff_t rsize, rgap = 0;
             rsize =
                 opal_datatype_span(&t->rdtype->super,
                                    (int64_t) t->rcount * low_size * up_size,
                                    &rgap);
-            reorder_buf = (char *) malloc(rsize);
+            if (mca_coll_han_component.han_use_persist_buffers && t->han_module != NULL) {
+                reorder_buf = han_scratch_alloc(&t->han_module->scratch_buf[1],
+                                                &t->han_module->scratch_buf_size[1],
+                                                (size_t)rsize);
+                if (NULL == reorder_buf) return OMPI_ERR_OUT_OF_RESOURCE;
+            } else {
+                reorder_buf = (char *) malloc(rsize);
+            }
             reorder_rbuf = reorder_buf - rgap;
         }
 
@@ -223,7 +388,9 @@ int mca_coll_han_allgather_uag_task(void *task_args)
                                            t->up_comm, t->up_comm->c_coll->coll_allgather_module);
 
         if (t->sbuf_inter_free != NULL) {
-            free(t->sbuf_inter_free);
+            han_free_frag(&t->han_module->fragment_freelist,
+                          t->inter_frag, t->sbuf_inter_free);
+            t->inter_frag = NULL;
             t->sbuf_inter_free = NULL;
         }
 
@@ -253,12 +420,15 @@ int mca_coll_han_allgather_uag_task(void *task_args)
                                                         (ptrdiff_t) t->rcount);
                 }
             }
-            free(reorder_buf);
+            if (!mca_coll_han_component.han_use_persist_buffers) {
+                free(reorder_buf);
+            }
             reorder_buf = NULL;
         }
     }
 
-
+allgather_done:
+    ; /* empty statement required after label before declaration */
     /* Create lb (low level broadcast) task */
     mca_coll_task_t *lb = t->cur_task;
     /* Init and issue lb task */
@@ -288,6 +458,340 @@ int mca_coll_han_allgather_lb_task(void *task_args)
 
 }
 
+/**
+ * Reorder a fragment from gathered layout into rbuf at the correct offset.
+ * Used by the pipeline and single-fragment paths.
+ */
+static inline void
+han_reorder_frag(char *rbuf, const char *src_buf,
+                 struct ompi_datatype_t *rdtype, ptrdiff_t rextent,
+                 size_t frag_count, size_t frag_offset, size_t rcount,
+                 int up_size, int low_size, const int *topo)
+{
+    for (int i = 0; i < up_size; i++) {
+        for (int j = 0; j < low_size; j++) {
+            int global_idx = i * low_size + j;
+            int dest_rank = topo[global_idx * 2 + 1];
+            ompi_datatype_copy_content_same_ddt(rdtype,
+                (ptrdiff_t)frag_count,
+                rbuf + rextent * ((ptrdiff_t)dest_rank * (ptrdiff_t)rcount
+                                  + (ptrdiff_t)frag_offset),
+                (char *)src_buf + rextent * (ptrdiff_t)global_idx
+                                * (ptrdiff_t)frag_count);
+        }
+    }
+}
+
+/**
+ * Mapbycore fast path: gather directly into rbuf, in-place allgather,
+ * single bcast. No temporary buffers needed.
+ */
+static int
+han_allgather_mapbycore(const void *sbuf, size_t scount,
+                        struct ompi_datatype_t *sdtype,
+                        void *rbuf, size_t rcount,
+                        struct ompi_datatype_t *rdtype,
+                        struct ompi_communicator_t *up_comm,
+                        struct ompi_communicator_t *low_comm,
+                        int w_rank, int low_rank, int up_rank,
+                        int low_size, int up_size, int root_low_rank)
+{
+    ptrdiff_t rlb, rext;
+    ompi_datatype_get_extent(rdtype, &rlb, &rext);
+    size_t total_count = rcount * low_size;
+    char *my_slot = (char *)rbuf + (ptrdiff_t)up_rank * (ptrdiff_t)total_count * rext;
+
+    if (MPI_IN_PLACE == sbuf) {
+        if (low_rank == root_low_rank) {
+            low_comm->c_coll->coll_gather(MPI_IN_PLACE, scount, sdtype,
+                                          my_slot, rcount, rdtype, root_low_rank,
+                                          low_comm, low_comm->c_coll->coll_gather_module);
+        } else {
+            char *my_data = ((char*)rbuf) + (ptrdiff_t)w_rank * (ptrdiff_t)rcount * rext;
+            low_comm->c_coll->coll_gather(my_data, rcount, rdtype,
+                                          NULL, rcount, rdtype, root_low_rank,
+                                          low_comm, low_comm->c_coll->coll_gather_module);
+        }
+    } else {
+        low_comm->c_coll->coll_gather((char *)sbuf, scount, sdtype,
+                                      my_slot, rcount, rdtype, root_low_rank,
+                                      low_comm, low_comm->c_coll->coll_gather_module);
+    }
+
+    if (low_rank == root_low_rank) {
+        up_comm->c_coll->coll_allgather(MPI_IN_PLACE, total_count, rdtype,
+                                        rbuf, total_count, rdtype,
+                                        up_comm, up_comm->c_coll->coll_allgather_module);
+    }
+
+    low_comm->c_coll->coll_bcast(rbuf, rcount*low_size*up_size, rdtype,
+                                 root_low_rank, low_comm,
+                                 low_comm->c_coll->coll_bcast_module);
+    return OMPI_SUCCESS;
+}
+
+/**
+ * Single-fragment freelist path: gather into reorder_buf, in-place
+ * allgather, reorder into rbuf, bcast.
+ */
+static int
+han_allgather_single_frag(const void *sbuf, size_t scount,
+                          struct ompi_datatype_t *sdtype,
+                          void *rbuf, size_t rcount,
+                          struct ompi_datatype_t *rdtype,
+                          mca_coll_han_module_t *han_module,
+                          struct ompi_communicator_t *up_comm,
+                          struct ompi_communicator_t *low_comm,
+                          struct ompi_communicator_t *comm,
+                          int w_rank, int low_rank, int up_rank,
+                          int low_size, int up_size, int root_low_rank,
+                          size_t frag_size, const int *topo)
+{
+    ptrdiff_t rlb, rext, rextent;
+    ompi_datatype_get_extent(rdtype, &rlb, &rext);
+    ompi_datatype_type_extent(rdtype, &rextent);
+    size_t total_count = rcount * low_size;
+    char *reorder_buf = NULL;
+    char *reorder_buf_start = NULL;
+    char *my_slot = NULL;
+    opal_free_list_item_t *fl_item = NULL;
+
+    if (low_rank == root_low_rank) {
+        ptrdiff_t rsize, rgap = 0;
+        rsize = opal_datatype_span(&rdtype->super,
+            (int64_t)rcount * low_size * up_size, &rgap);
+
+        reorder_buf = han_alloc_frag(&han_module->fragment_freelist,
+                                     frag_size, (size_t)rsize, &fl_item);
+        if (NULL == reorder_buf) {
+            return OMPI_ERR_OUT_OF_RESOURCE;
+        }
+        reorder_buf_start = reorder_buf - rgap;
+        my_slot = reorder_buf_start
+            + rextent * (ptrdiff_t)up_rank * (ptrdiff_t)total_count;
+        if (MPI_IN_PLACE == sbuf) {
+            char *my_data = ((char*)rbuf) + (ptrdiff_t)w_rank * (ptrdiff_t)rcount * rext;
+            ompi_datatype_copy_content_same_ddt(rdtype, rcount, my_slot, my_data);
+        }
+    }
+
+    if (MPI_IN_PLACE == sbuf) {
+        if (low_rank == root_low_rank) {
+            low_comm->c_coll->coll_gather(MPI_IN_PLACE, scount, sdtype,
+                my_slot, rcount, rdtype, root_low_rank,
+                low_comm, low_comm->c_coll->coll_gather_module);
+        } else {
+            char *my_data = ((char*)rbuf) + (ptrdiff_t)w_rank * (ptrdiff_t)rcount * rext;
+            low_comm->c_coll->coll_gather(my_data, rcount, rdtype,
+                NULL, rcount, rdtype, root_low_rank,
+                low_comm, low_comm->c_coll->coll_gather_module);
+        }
+    } else {
+        low_comm->c_coll->coll_gather((char *)sbuf, scount, sdtype,
+            my_slot, rcount, rdtype, root_low_rank,
+            low_comm, low_comm->c_coll->coll_gather_module);
+    }
+
+    if (low_rank == root_low_rank) {
+        up_comm->c_coll->coll_allgather(MPI_IN_PLACE, total_count, rdtype,
+            reorder_buf_start, total_count, rdtype,
+            up_comm, up_comm->c_coll->coll_allgather_module);
+
+        ompi_coll_han_reorder_gather(reorder_buf_start, rbuf, rcount, rdtype, comm, topo);
+        han_free_frag(&han_module->fragment_freelist, fl_item, reorder_buf);
+    }
+
+    low_comm->c_coll->coll_bcast(rbuf, rcount * low_size * up_size, rdtype,
+        root_low_rank, low_comm, low_comm->c_coll->coll_bcast_module);
+    return OMPI_SUCCESS;
+}
+
+/**
+ * Pipeline path: double-buffered igather+ibcast with blocking low_comm
+ * gather as the sync point.
+ */
+static int
+han_allgather_pipeline(const void *sbuf, size_t scount,
+                       struct ompi_datatype_t *sdtype,
+                       void *rbuf, size_t rcount,
+                       struct ompi_datatype_t *rdtype,
+                       mca_coll_han_module_t *han_module,
+                       struct ompi_communicator_t *up_comm,
+                       struct ompi_communicator_t *low_comm,
+                       int w_rank, int low_rank,
+                       int low_size, int up_size, int root_low_rank,
+                       size_t frag_size, size_t frag_count, size_t num_frags,
+                       const int *topo)
+{
+    ptrdiff_t rlb, rext, rextent;
+    int root_up_rank = 0;
+    ompi_datatype_get_extent(rdtype, &rlb, &rext);
+    ompi_datatype_type_extent(rdtype, &rextent);
+
+    /* Pipeline requires non-blocking collectives on up_comm */
+    if (NULL == up_comm->c_coll->coll_ibcast
+        || NULL == up_comm->c_coll->coll_igather) {
+        return OMPI_ERR_NOT_SUPPORTED;
+    }
+
+    /* Allocate double-buffered reorder buffers */
+    char *frag_reorder[2] = {NULL, NULL};
+    opal_free_list_item_t *frag_reorder_item[2] = {NULL, NULL};
+    int frag_reorder_src[2] = {HAN_ALLOC_MALLOC, HAN_ALLOC_MALLOC};
+    if (low_rank == root_low_rank) {
+        size_t frag_reorder_size = (size_t)frag_count * low_size * up_size * rextent;
+        size_t large_frag_size = mca_coll_han_component.han_large_fragment_size;
+        for (int b = 0; b < 2; b++) {
+            frag_reorder[b] = han_alloc_tiered(
+                &han_module->large_fragment_freelist, large_frag_size,
+                &han_module->fragment_freelist, frag_size,
+                frag_reorder_size, &frag_reorder_item[b],
+                &frag_reorder_src[b]);
+            if (NULL == frag_reorder[b]) {
+                for (int i = 0; i < b; i++) {
+                    han_free_tiered(&han_module->large_fragment_freelist,
+                                    &han_module->fragment_freelist,
+                                    frag_reorder_item[i], frag_reorder[i],
+                                    frag_reorder_src[i]);
+                }
+                return OMPI_ERR_OUT_OF_RESOURCE;
+            }
+        }
+    }
+
+    opal_free_list_item_t *inter_frag_item = NULL;
+    char *gather_buf = NULL;
+    ompi_request_t *igather_req = NULL;
+    ompi_request_t *ibcast_req = NULL;
+    size_t prev_frag_count = 0;
+    size_t prev_frag_offset = 0;
+    int cur_buf = 0;
+
+    for (size_t frag = 0; frag < num_frags; frag++) {
+        size_t frag_offset = frag * frag_count;
+        size_t this_count = frag_count;
+        if (frag_offset + this_count > rcount)
+            this_count = rcount - frag_offset;
+
+        int prev_buf = 1 - cur_buf;
+
+        if (frag > 0 && low_rank == root_low_rank) {
+            ompi_request_wait(&igather_req, MPI_STATUS_IGNORE);
+            igather_req = NULL;
+
+            han_free_frag(&han_module->fragment_freelist,
+                          inter_frag_item, gather_buf);
+            inter_frag_item = NULL;
+            gather_buf = NULL;
+
+            size_t prev_ag = prev_frag_count * low_size * up_size;
+            up_comm->c_coll->coll_ibcast(frag_reorder[prev_buf], prev_ag, rdtype,
+                root_up_rank, up_comm, &ibcast_req,
+                up_comm->c_coll->coll_ibcast_module);
+        }
+
+        if (low_rank == root_low_rank) {
+            gather_buf = han_alloc_frag(&han_module->fragment_freelist,
+                                        frag_size,
+                                        (size_t)this_count * low_size * rextent,
+                                        &inter_frag_item);
+            if (NULL == gather_buf) {
+                /* Clean up any outstanding ibcast and double buffers */
+                if (ibcast_req != NULL) {
+                    ompi_request_wait(&ibcast_req, MPI_STATUS_IGNORE);
+                }
+                for (int b = 0; b < 2; b++) {
+                    han_free_tiered(&han_module->large_fragment_freelist,
+                                    &han_module->fragment_freelist,
+                                    frag_reorder_item[b], frag_reorder[b],
+                                    frag_reorder_src[b]);
+                }
+                return OMPI_ERR_OUT_OF_RESOURCE;
+            }
+            if (MPI_IN_PLACE == sbuf) {
+                char *my_data = ((char*)rbuf)
+                    + ((ptrdiff_t)w_rank * (ptrdiff_t)rcount + (ptrdiff_t)frag_offset) * rext;
+                ompi_datatype_copy_content_same_ddt(rdtype, this_count,
+                    gather_buf, my_data);
+            }
+        }
+
+        /* ALL ranks: blocking low_comm gather — SYNC POINT */
+        if (MPI_IN_PLACE == sbuf) {
+            if (low_rank == root_low_rank) {
+                low_comm->c_coll->coll_gather(MPI_IN_PLACE, this_count, rdtype,
+                    gather_buf, this_count, rdtype, root_low_rank,
+                    low_comm, low_comm->c_coll->coll_gather_module);
+            } else {
+                char *my_data = ((char*)rbuf)
+                    + ((ptrdiff_t)w_rank * (ptrdiff_t)rcount + (ptrdiff_t)frag_offset) * rext;
+                low_comm->c_coll->coll_gather(my_data, this_count, rdtype,
+                    NULL, this_count, rdtype, root_low_rank,
+                    low_comm, low_comm->c_coll->coll_gather_module);
+            }
+        } else {
+            low_comm->c_coll->coll_gather(
+                (char *)sbuf + (ptrdiff_t)frag_offset * rext, this_count, sdtype,
+                gather_buf, this_count, rdtype, root_low_rank,
+                low_comm, low_comm->c_coll->coll_gather_module);
+        }
+
+        if (low_rank == root_low_rank) {
+            size_t ag_count = this_count * low_size;
+            up_comm->c_coll->coll_igather(gather_buf, ag_count, rdtype,
+                frag_reorder[cur_buf], ag_count, rdtype, root_up_rank,
+                up_comm, &igather_req, up_comm->c_coll->coll_igather_module);
+        }
+
+        if (frag > 0 && low_rank == root_low_rank) {
+            ompi_request_wait(&ibcast_req, MPI_STATUS_IGNORE);
+            ibcast_req = NULL;
+
+            han_reorder_frag(rbuf, frag_reorder[prev_buf], rdtype, rextent,
+                             prev_frag_count, prev_frag_offset, rcount,
+                             up_size, low_size, topo);
+        }
+
+        prev_frag_count = this_count;
+        prev_frag_offset = frag_offset;
+        cur_buf = 1 - cur_buf;
+    }
+
+    /* Epilogue: last frag */
+    if (low_rank == root_low_rank) {
+        int last_buf = 1 - cur_buf;
+
+        if (igather_req != NULL) {
+            ompi_request_wait(&igather_req, MPI_STATUS_IGNORE);
+        }
+
+        han_free_frag(&han_module->fragment_freelist,
+                      inter_frag_item, gather_buf);
+
+        size_t last_ag = prev_frag_count * low_size * up_size;
+        up_comm->c_coll->coll_ibcast(frag_reorder[last_buf], last_ag, rdtype,
+            root_up_rank, up_comm, &ibcast_req,
+            up_comm->c_coll->coll_ibcast_module);
+        ompi_request_wait(&ibcast_req, MPI_STATUS_IGNORE);
+
+        han_reorder_frag(rbuf, frag_reorder[last_buf], rdtype, rextent,
+                         prev_frag_count, prev_frag_offset, rcount,
+                         up_size, low_size, topo);
+
+        for (int b = 0; b < 2; b++) {
+            han_free_tiered(&han_module->large_fragment_freelist,
+                            &han_module->fragment_freelist,
+                            frag_reorder_item[b], frag_reorder[b],
+                            frag_reorder_src[b]);
+        }
+    }
+
+    low_comm->c_coll->coll_bcast(rbuf, rcount * low_size * up_size, rdtype,
+                                 root_low_rank, low_comm,
+                                 low_comm->c_coll->coll_bcast_module);
+    return OMPI_SUCCESS;
+}
+
 /**
  * Short implementation of allgather that only does hierarchical
  * communications without tasks.
@@ -300,6 +804,7 @@ mca_coll_han_allgather_intra_simple(const void *sbuf, size_t scount,
                                     struct ompi_communicator_t *comm,
                                     mca_coll_base_module_t *module){
 
+
     /* create the subcommunicators */
     mca_coll_han_module_t *han_module = (mca_coll_han_module_t *)module;
 
@@ -336,101 +841,172 @@ mca_coll_han_allgather_intra_simple(const void *sbuf, size_t scount,
     int up_size = ompi_comm_size(up_comm);
     int root_low_rank = 0; // node leader will be 0 on each rank
 
-    /* allocate the intermediary buffer
-     * to gather on leaders on the low sub communicator */
-    ptrdiff_t rlb, rext;
-    ompi_datatype_get_extent (rdtype, &rlb, &rext);
-    char *tmp_buf = NULL;
-    char *tmp_buf_start = NULL;
-    char *tmp_send = NULL;
-    if (MPI_IN_PLACE == sbuf) {
-        scount = rcount;
-        sdtype = rdtype;
-    }
-    if (low_rank == root_low_rank) {
-        ptrdiff_t rsize, rgap = 0;
-        /* Compute the size to receive all the local data, including datatypes empty gaps */
-        rsize = opal_datatype_span(&rdtype->super, (int64_t)rcount * low_size, &rgap);
-        /* intermediary buffer on node leaders to gather on low comm */
-        tmp_buf = (char *) malloc(rsize);
-        tmp_buf_start = tmp_buf - rgap;
+    /* Check if freelist-based optimization is enabled.
+     * Only use optimized path when the gathered data per node is large
+     * enough that pipeline/mapbycore benefit outweighs setup overhead.
+     * With MIN_PIPELINE_FRAGS=4, the threshold ensures at least 4
+     * fragments worth of data, so the pipeline has enough stages to
+     * overlap igather and ibcast effectively. */
+    size_t frag_size = mca_coll_han_component.han_fragment_size;
+    ptrdiff_t rextent_check;
+    ompi_datatype_type_extent(rdtype, &rextent_check);
+    size_t gathered_size = (size_t)rcount * (size_t)low_size * (size_t)rextent_check;
+    if (frag_size == 0 || gathered_size <= (HAN_MIN_PIPELINE_FRAGS * frag_size)) {
+        /*
+         * Simple path: gather to tmp_buf, allgather between leaders,
+         * reorder if needed, bcast to all ranks.
+         */
+        ptrdiff_t rlb, rext;
+        ompi_datatype_get_extent (rdtype, &rlb, &rext);
+        char *tmp_buf = NULL;
+        char *tmp_buf_start = NULL;
+        char *tmp_send = NULL;
         if (MPI_IN_PLACE == sbuf) {
-            tmp_send = ((char*)rbuf) + (ptrdiff_t)w_rank * (ptrdiff_t)rcount * rext;
-            ompi_datatype_copy_content_same_ddt(rdtype, rcount, tmp_buf_start, tmp_send);
+            scount = rcount;
+            sdtype = rdtype;
         }
-    }
-
-    /* 1. low gather on node leaders into tmp_buf */
-    if (MPI_IN_PLACE == sbuf) {
         if (low_rank == root_low_rank) {
-            low_comm->c_coll->coll_gather(MPI_IN_PLACE, scount, sdtype,
-                                          tmp_buf_start, rcount, rdtype, root_low_rank,
-                                          low_comm, low_comm->c_coll->coll_gather_module);
+            ptrdiff_t rsize, rgap = 0;
+            /* Compute the size to receive all the local data, including datatypes empty gaps */
+            rsize = opal_datatype_span(&rdtype->super, (int64_t)rcount * low_size, &rgap);
+            /* intermediary buffer on node leaders to gather on low comm */
+            tmp_buf = han_scratch_or_malloc(&han_module->scratch_buf[1],
+                                            &han_module->scratch_buf_size[1],
+                                            rsize, mca_coll_han_component.han_use_persist_buffers);
+            if (NULL == tmp_buf) {
+                return OMPI_ERR_OUT_OF_RESOURCE;
+            }
+            tmp_buf_start = tmp_buf - rgap;
+            if (MPI_IN_PLACE == sbuf) {
+                tmp_send = ((char*)rbuf) + (ptrdiff_t)w_rank * (ptrdiff_t)rcount * rext;
+                ompi_datatype_copy_content_same_ddt(rdtype, rcount, tmp_buf_start, tmp_send);
+            }
+        }
+
+        /* 1. low gather on node leaders into tmp_buf */
+        if (MPI_IN_PLACE == sbuf) {
+            if (low_rank == root_low_rank) {
+                low_comm->c_coll->coll_gather(MPI_IN_PLACE, scount, sdtype,
+                                              tmp_buf_start, rcount, rdtype, root_low_rank,
+                                              low_comm, low_comm->c_coll->coll_gather_module);
+            }
+            else {
+                tmp_send = ((char*)rbuf) + (ptrdiff_t)w_rank * (ptrdiff_t)rcount * rext;
+                low_comm->c_coll->coll_gather(tmp_send, rcount, rdtype,
+                                              NULL, rcount, rdtype, root_low_rank,
+                                              low_comm, low_comm->c_coll->coll_gather_module);
+            }
         }
         else {
-            tmp_send = ((char*)rbuf) + (ptrdiff_t)w_rank * (ptrdiff_t)rcount * rext;
-            low_comm->c_coll->coll_gather(tmp_send, rcount, rdtype,
-                                          NULL, rcount, rdtype, root_low_rank,
+            low_comm->c_coll->coll_gather((char *)sbuf, scount, sdtype,
+                                          tmp_buf_start, rcount, rdtype, root_low_rank,
                                           low_comm, low_comm->c_coll->coll_gather_module);
         }
-    }
-    else {
-        low_comm->c_coll->coll_gather((char *)sbuf, scount, sdtype,
-                                      tmp_buf_start, rcount, rdtype, root_low_rank,
-                                      low_comm, low_comm->c_coll->coll_gather_module);
-    }
-    /* 2. allgather between node leaders, from tmp_buf to reorder_buf */
-    if (low_rank == root_low_rank) {
-        /* allocate buffer to store unordered result on node leaders
-         * if the processes are mapped-by core, no need to reorder:
-         * distribution of ranks on core first and node next,
-         * in a increasing order for both patterns.
-         */
-        char *reorder_buf = NULL;
-        char *reorder_buf_start = NULL;
-        if (han_module->is_mapbycore) {
-            reorder_buf_start = rbuf;
-        } else {
-            if (0 == low_rank && 0 == up_rank) { // first rank displays message
-                OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
-                                     "[%d]: Future Allgather needs reordering: ", up_rank));
+        /* 2. allgather between node leaders, from tmp_buf to reorder_buf */
+        if (low_rank == root_low_rank) {
+            /* allocate buffer to store unordered result on node leaders
+             * if the processes are mapped-by core, no need to reorder:
+             * distribution of ranks on core first and node next,
+             * in a increasing order for both patterns.
+             */
+            char *reorder_buf = NULL;
+            char *reorder_buf_start = NULL;
+            if (han_module->is_mapbycore) {
+                reorder_buf_start = rbuf;
+            } else {
+                if (0 == low_rank && 0 == up_rank) { // first rank displays message
+                    OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
+                                         "[%d]: Future Allgather needs reordering: ", up_rank));
+                }
+                ptrdiff_t rsize, rgap = 0;
+                rsize = opal_datatype_span(&rdtype->super, (int64_t)rcount * low_size * up_size, &rgap);
+                reorder_buf = han_scratch_or_malloc(&han_module->scratch_buf[0],
+                                                     &han_module->scratch_buf_size[0],
+                                                     rsize, mca_coll_han_component.han_use_persist_buffers);
+                reorder_buf_start = reorder_buf - rgap;
             }
-            ptrdiff_t rsize, rgap = 0;
-            rsize = opal_datatype_span(&rdtype->super, (int64_t)rcount * low_size * up_size, &rgap);
-            reorder_buf = (char *) malloc(rsize);
-            reorder_buf_start = reorder_buf - rgap;
-        }
 
-        /* 2a. inter node allgather */
-        up_comm->c_coll->coll_allgather(tmp_buf_start, scount*low_size, sdtype,
-                                        reorder_buf_start, rcount*low_size, rdtype,
-                                        up_comm, up_comm->c_coll->coll_allgather_module);
+            /* 2a. inter node allgather */
+            up_comm->c_coll->coll_allgather(tmp_buf_start, scount*low_size, sdtype,
+                                            reorder_buf_start, rcount*low_size, rdtype,
+                                            up_comm, up_comm->c_coll->coll_allgather_module);
+
+            if (tmp_buf != NULL && !mca_coll_han_component.han_use_persist_buffers) {
+                free(tmp_buf);
+                tmp_buf = NULL;
+                tmp_buf_start = NULL;
+            }
+
+            /* 2b. reorder the node leader's into rbuf.
+             * if ranks are not mapped in topological order, data needs to be reordered
+             * (see reorder_gather)
+             */
+            if (!han_module->is_mapbycore) {
+                ompi_coll_han_reorder_gather(reorder_buf_start,
+                                             rbuf, rcount, rdtype,
+                                             comm, topo);
+                if (!mca_coll_han_component.han_use_persist_buffers) {
+                    free(reorder_buf);
+                }
+                reorder_buf = NULL;
+            }
 
-        if (tmp_buf != NULL) {
-            free(tmp_buf);
-            tmp_buf = NULL;
-            tmp_buf_start = NULL;
         }
 
-        /* 2b. reorder the node leader's into rbuf.
-         * if ranks are not mapped in topological order, data needs to be reordered
-         * (see reorder_gather)
+        /* 3. up broadcast: leaders broadcast on their nodes */
+        low_comm->c_coll->coll_bcast(rbuf, rcount*low_size*up_size, rdtype,
+                                     root_low_rank, low_comm,
+                                     low_comm->c_coll->coll_bcast_module);
+
+    } else {
+        /*
+         * Freelist path: uses pre-allocated buffers and mapbycore/pipeline
+         * optimizations for large messages.
          */
-        if (!han_module->is_mapbycore) {
-            ompi_coll_han_reorder_gather(reorder_buf_start,
-                                         rbuf, rcount, rdtype,
-                                         comm, topo);
-            free(reorder_buf);
-            reorder_buf = NULL;
-        }
+        ptrdiff_t rextent;
+        size_t frag_count;
+        size_t num_frags;
+        size_t max_elems;
 
-    }
+        ompi_datatype_type_extent(rdtype, &rextent);
 
-    /* 3. up broadcast: leaders broadcast on their nodes */
-    low_comm->c_coll->coll_bcast(rbuf, rcount*low_size*up_size, rdtype,
-                                 root_low_rank, low_comm,
-                                 low_comm->c_coll->coll_bcast_module);
+        if (MPI_IN_PLACE == sbuf) {
+            scount = rcount;
+            sdtype = rdtype;
+        }
+
+        /* Compute per-fragment element count */
+        frag_count = rcount;
+        if (frag_size > 0 && rextent > 0) {
+            max_elems = frag_size / ((size_t)low_size * (size_t)rextent);
+            if (max_elems < 1) max_elems = 1;
+            if (max_elems < rcount) frag_count = max_elems;
+        }
+        num_frags = (rcount + frag_count - 1) / frag_count;
 
+        if (han_module->is_mapbycore) {
+            return han_allgather_mapbycore(sbuf, scount, sdtype, rbuf, rcount,
+                rdtype, up_comm, low_comm, w_rank, low_rank, up_rank,
+                low_size, up_size, root_low_rank);
+        } else if (num_frags == 1) {
+            return han_allgather_single_frag(sbuf, scount, sdtype, rbuf, rcount,
+                rdtype, han_module, up_comm, low_comm, comm,
+                w_rank, low_rank, up_rank, low_size, up_size,
+                root_low_rank, frag_size, topo);
+        } else {
+            int rc = han_allgather_pipeline(sbuf, scount, sdtype, rbuf, rcount,
+                rdtype, han_module, up_comm, low_comm,
+                w_rank, low_rank, low_size, up_size,
+                root_low_rank, frag_size, frag_count, num_frags, topo);
+            if (OMPI_ERR_NOT_SUPPORTED == rc) {
+                return han_allgather_single_frag(sbuf, scount, sdtype, rbuf, rcount,
+                    rdtype, han_module, up_comm, low_comm, comm,
+                    w_rank, low_rank, up_rank, low_size, up_size,
+                    root_low_rank, frag_size, topo);
+            }
+            return rc;
+        }
+    }
 
     return OMPI_SUCCESS;
-}
+}
\ No newline at end of file
diff --git a/ompi/mca/coll/han/coll_han_alltoall.c b/ompi/mca/coll/han/coll_han_alltoall.c
index 489dd41e35a..af4e1e7ac68 100644
--- a/ompi/mca/coll/han/coll_han_alltoall.c
+++ b/ompi/mca/coll/han/coll_han_alltoall.c
@@ -60,6 +60,62 @@ static inline int ring_partner(int rank, int round, int comm_size) {
         return ring_partner_no_skip(rank, round+1, comm_size);
 }
 
+
+/**
+ * Set up or reuse cached SMSC arrays for alltoall.
+ * Returns 1 if cache was valid (allgather + map can be skipped),
+ * 0 on cache miss (arrays allocated, caller must populate),
+ * or -1 on allocation failure.
+ */
+static int alltoall_cache_setup(
+    mca_coll_han_module_t *han_module,
+    const void *sbuf, size_t scount, int low_size,
+    char ***low_bufs_out, void ***map_ctx_out, void ***gather_buf_out,
+    int *send_needs_bounce_out, int *ii_push_data_out)
+{
+    struct han_alltoall_cache *c = &han_module->a2a_cache;
+    const int nptrs_gather = 3;
+
+    if (c->cached_sbuf == sbuf
+        && c->cached_scount == scount
+        && c->cached_low_size == low_size
+        && c->low_bufs != NULL) {
+        *low_bufs_out = c->low_bufs;
+        *map_ctx_out = c->map_ctx;
+        *gather_buf_out = c->gather_buf;
+        *send_needs_bounce_out = c->cached_send_needs_bounce;
+        *ii_push_data_out = c->cached_ii_push_data;
+        return 1; /* cache valid */
+    }
+
+    /* Invalidate old cache — unmap old SMSC regions */
+    if (c->map_ctx) {
+        for (int i = 0; i < c->cached_low_size; i++) {
+            if (c->map_ctx[i])
+                mca_smsc->unmap_peer_region(c->map_ctx[i]);
+        }
+    }
+    /* Allocate/reuse persistent arrays */
+    if (c->cached_low_size < low_size) {
+        free(c->low_bufs);
+        free(c->map_ctx);
+        free(c->gather_buf);
+        c->cached_low_size = 0;
+        c->low_bufs = malloc(low_size * sizeof(char*));
+        c->map_ctx = malloc(low_size * sizeof(void*));
+        c->gather_buf = calloc(low_size * nptrs_gather, sizeof(void*));
+        if (NULL == c->low_bufs || NULL == c->map_ctx || NULL == c->gather_buf) {
+            return -1; /* allocation failure */
+        }
+    }
+    *low_bufs_out = c->low_bufs;
+    *map_ctx_out = c->map_ctx;
+    *gather_buf_out = c->gather_buf;
+    memset(c->map_ctx, 0, low_size * sizeof(void*));
+    memset(c->gather_buf, 0, low_size * nptrs_gather * sizeof(void*));
+    return 0; /* cache miss */
+}
+
 int mca_coll_han_alltoall_using_smsc(
         const void *sbuf, size_t scount,
         struct ompi_datatype_t *sdtype,
@@ -218,14 +274,31 @@ int mca_coll_han_alltoall_using_smsc(
     int64_t send_bytes_per_fan = low_size * packed_size;
     inter_send_reqs = malloc(sizeof(*inter_send_reqs) * fanout);
     inter_recv_reqs = malloc(sizeof(*inter_recv_reqs) * up_size );
-    char **low_bufs = malloc(low_size * sizeof(*low_bufs));
-    void **sbuf_map_ctx = malloc(low_size * sizeof(&sbuf_map_ctx));
-    opal_free_list_item_t *send_fl_item = NULL;
 
+    /* Check if cached SMSC mappings are still valid */
+    int a2a_cache_valid;
+    char **low_bufs = NULL;
+    void **sbuf_map_ctx = NULL;
+    opal_free_list_item_t *send_fl_item = NULL;
     const int nptrs_gather = 3;
-    void **gather_buf_out = calloc(low_size*nptrs_gather, sizeof(void*));
+    void **gather_buf_out = NULL;
     int send_bounce_status = BOUNCE_NOT_INITIALIZED;
 
+    if (mca_coll_han_component.han_use_persist_buffers) {
+        int cache_rc = alltoall_cache_setup(
+            han_module, sbuf, scount, low_size,
+            &low_bufs, &sbuf_map_ctx, &gather_buf_out,
+            &send_needs_bounce, &ii_push_data);
+        if (cache_rc < 0) { rc = OMPI_ERR_OUT_OF_RESOURCE; goto cleanup; }
+        a2a_cache_valid = (cache_rc == 1);
+    } else {
+        /* Original upstream path — fresh allocations per call */
+        a2a_cache_valid = 0;
+        low_bufs = malloc(low_size * sizeof(*low_bufs));
+        sbuf_map_ctx = malloc(low_size * sizeof(*sbuf_map_ctx));
+        gather_buf_out = calloc(low_size * nptrs_gather, sizeof(void*));
+    }
+
     do {
 start_allgather:
         if ( 0 == send_needs_bounce ) {
@@ -233,70 +306,96 @@ int mca_coll_han_alltoall_using_smsc(
             send_bounce_status = BOUNCE_IS_FROM_RBUF;
         } else {
             if (send_bounce_status == BOUNCE_NOT_INITIALIZED || send_bounce_status == BOUNCE_IS_FROM_RBUF) {
-                if (send_bytes_per_fan * fanout < mca_coll_han_component.han_packbuf_bytes) {
-                    send_fl_item = opal_free_list_get(&mca_coll_han_component.pack_buffers);
-                    if (send_fl_item) {
-                        send_bounce_status = BOUNCE_IS_FROM_FREELIST;
-                        send_bounce = send_fl_item->ptr;
+                if (mca_coll_han_component.han_use_persist_buffers) {
+                    /* Persistent bounce: realloc-to-HWM avoids munmap on free
+                     * which would invalidate NIC memory registration cache entries. */
+                    size_t needed = send_bytes_per_fan * fanout;
+                    if (han_module->a2a_cache.bounce_size < needed) {
+                        char *p = realloc(han_module->a2a_cache.bounce, needed);
+                        if (NULL == p) { rc = OMPI_ERR_OUT_OF_RESOURCE; goto cleanup; }
+                        han_module->a2a_cache.bounce = p;
+                        han_module->a2a_cache.bounce_size = needed;
                     }
-                }
-                if (!send_fl_item) {
-                    send_bounce = malloc(send_bytes_per_fan * fanout);
+                    send_bounce = han_module->a2a_cache.bounce;
                     send_bounce_status = BOUNCE_IS_FROM_MALLOC;
+                } else {
+                    if (send_bytes_per_fan * fanout < mca_coll_han_component.han_packbuf_bytes) {
+                        send_fl_item = opal_free_list_get(&mca_coll_han_component.pack_buffers);
+                        if (send_fl_item) {
+                            send_bounce_status = BOUNCE_IS_FROM_FREELIST;
+                            send_bounce = send_fl_item->ptr;
+                        }
+                    }
+                    if (!send_fl_item) {
+                        send_bounce = malloc(send_bytes_per_fan * fanout);
+                        send_bounce_status = BOUNCE_IS_FROM_MALLOC;
+                    }
                 }
             }
         }
 
-        if (ii_push_data) {
-            /* all ranks will push to the other ranks' bounce buffer */
-            gather_buf_in[0] = send_bounce;
-        } else {
-            /* all ranks will pull from the other ranks' sbuf */
-            gather_buf_in[0] = (void*)sbuf;
-        }
-        gather_buf_in[1] = (void*)(intptr_t)send_needs_bounce;
-        gather_buf_in[2] = (void*)(intptr_t)ii_push_data;
+        if (!a2a_cache_valid) {
+            if (ii_push_data) {
+                /* all ranks will push to the other ranks' bounce buffer */
+                gather_buf_in[0] = send_bounce;
+            } else {
+                /* all ranks will pull from the other ranks' sbuf */
+                gather_buf_in[0] = (void*)sbuf;
+            }
+            gather_buf_in[1] = (void*)(intptr_t)send_needs_bounce;
+            gather_buf_in[2] = (void*)(intptr_t)ii_push_data;
 
-        rc = low_comm->c_coll->coll_allgather(gather_buf_in, nptrs_gather, MPI_AINT,
-                    gather_buf_out, nptrs_gather, MPI_AINT, low_comm,
-                    low_comm->c_coll->coll_allgather_module);
+            rc = low_comm->c_coll->coll_allgather(gather_buf_in, nptrs_gather, MPI_AINT,
+                        gather_buf_out, nptrs_gather, MPI_AINT, low_comm,
+                        low_comm->c_coll->coll_allgather_module);
 
-        if (rc != 0) {
-            OPAL_OUTPUT_VERBOSE((40, mca_coll_han_component.han_output,
-            "Allgather failed with %d\n",rc));
-            goto cleanup;
-        }
+            if (rc != 0) {
+                OPAL_OUTPUT_VERBOSE((40, mca_coll_han_component.han_output,
+                "Allgather failed with %d\n",rc));
+                goto cleanup;
+            }
 
-        for (int jother=0; jother<low_size; jother++) {
-            int other_push_data = (uintptr_t)gather_buf_out[nptrs_gather*jother + 2] & 0x1;
-            if (ii_push_data != other_push_data) {
-                ii_push_data = 1;
-                goto start_allgather;
+            for (int jother=0; jother<low_size; jother++) {
+                int other_push_data = (uintptr_t)gather_buf_out[nptrs_gather*jother + 2] & 0x1;
+                if (ii_push_data != other_push_data) {
+                    ii_push_data = 1;
+                    goto start_allgather;
+                }
+                send_needs_bounce  |= (uintptr_t)gather_buf_out[nptrs_gather*jother + 1] & 0x1;
+                ii_push_data       |= other_push_data;
             }
-            send_needs_bounce  |= (uintptr_t)gather_buf_out[nptrs_gather*jother + 1] & 0x1;
-            ii_push_data       |= other_push_data;
-        }
+        } /* !a2a_cache_valid */
     } while (0);
 
     use_isend = fanout > 1 || ii_push_data;
 
-    for (int jother=0; jother<low_size; jother++) {
-        low_bufs[jother] = gather_buf_out[nptrs_gather*jother];
-        if (jother == low_rank) {
-            sbuf_map_ctx[low_rank] = NULL;
-        } else {
-            struct ompi_proc_t* ompi_proc = ompi_comm_peer_lookup(low_comm, jother);
-            mca_smsc_endpoint_t *smsc_ep;
-            smsc_ep = mca_coll_han_get_smsc_endpoint(ompi_proc);
-
-            sbuf_map_ctx[jother] = mca_smsc->map_peer_region(
-                smsc_ep,
-                MCA_RCACHE_FLAGS_PERSIST,
-                low_bufs[jother],
-                sextent*w_size*scount,
-                (void**) &low_bufs[jother] );
+    if (!a2a_cache_valid) {
+        for (int jother=0; jother<low_size; jother++) {
+            low_bufs[jother] = gather_buf_out[nptrs_gather*jother];
+            if (jother == low_rank) {
+                sbuf_map_ctx[low_rank] = NULL;
+            } else {
+                struct ompi_proc_t* ompi_proc = ompi_comm_peer_lookup(low_comm, jother);
+                mca_smsc_endpoint_t *smsc_ep;
+                smsc_ep = mca_coll_han_get_smsc_endpoint(ompi_proc);
+
+                sbuf_map_ctx[jother] = mca_smsc->map_peer_region(
+                    smsc_ep,
+                    MCA_RCACHE_FLAGS_PERSIST,
+                    low_bufs[jother],
+                    sextent*w_size*scount,
+                    (void**) &low_bufs[jother] );
+            }
         }
-    }
+        /* Update cache (only when persist buffers enabled) */
+        if (mca_coll_han_component.han_use_persist_buffers) {
+            han_module->a2a_cache.cached_sbuf = sbuf;
+            han_module->a2a_cache.cached_scount = scount;
+            han_module->a2a_cache.cached_low_size = low_size;
+            han_module->a2a_cache.cached_send_needs_bounce = send_needs_bounce;
+            han_module->a2a_cache.cached_ii_push_data = ii_push_data;
+        }
+    } /* !a2a_cache_valid */
 
     for (int jslot=0; jslot < fanout; jslot++) {
         inter_send_reqs[jslot] = MPI_REQUEST_NULL;
@@ -305,12 +404,25 @@ int mca_coll_han_alltoall_using_smsc(
 
     /* pre-post all our receives.  We will be ready to receive all data regardless of fan-out.
        (This is not an in-place algorithm)*/
+    size_t recv_chunk_bytes = rextent * rcount * low_size;
+    size_t recv_total = recv_chunk_bytes * up_size;
+    if (mca_coll_han_component.han_use_persist_buffers) {
+        /* Use persistent recv buffer to keep MR addresses stable */
+        if (han_module->a2a_cache.recv_buf_size < recv_total) {
+            char *p = realloc(han_module->a2a_cache.recv_buf, recv_total);
+            if (NULL == p) { rc = OMPI_ERR_OUT_OF_RESOURCE; goto cleanup; }
+            han_module->a2a_cache.recv_buf = p;
+            han_module->a2a_cache.recv_buf_size = recv_total;
+        }
+    }
+
     int inter_recv_count = 0;
     for (int jround=0; jround<up_size; jround++) {
             int up_partner = ring_partner(up_rank, jround, up_size);
             int first_remote_wrank = up_partner*low_size;
-            /* pre-post the receive for remote.  Receive directly into application buffer */
-            char *recv_chunk = ((char*)rbuf) + rextent*rcount*first_remote_wrank;
+            char *recv_chunk = mca_coll_han_component.han_use_persist_buffers
+                ? han_module->a2a_cache.recv_buf + recv_chunk_bytes * jround
+                : ((char*)rbuf) + rextent*rcount*first_remote_wrank;
 
             MCA_PML_CALL(irecv
                         (recv_chunk, rcount*low_size, rdtype, first_remote_wrank+low_rank,
@@ -415,6 +527,17 @@ int mca_coll_han_alltoall_using_smsc(
     /* wait for all irecv to complete */
     ompi_request_wait_all(inter_recv_count, inter_recv_reqs, MPI_STATUS_IGNORE);
 
+    /* Copy from persistent recv buffer to application rbuf */
+    if (mca_coll_han_component.han_use_persist_buffers) {
+        for (int jround=0; jround<inter_recv_count; jround++) {
+            int up_partner = ring_partner(up_rank, jround, up_size);
+            int first_remote_wrank = up_partner*low_size;
+            memcpy(((char*)rbuf) + rextent*rcount*first_remote_wrank,
+                   han_module->a2a_cache.recv_buf + recv_chunk_bytes * jround,
+                   recv_chunk_bytes);
+        }
+    }
+
 cleanup:
 
     /* we may still have neighbors reading directly from our buffer, so we must ensure it is not modified */
@@ -423,22 +546,29 @@ int mca_coll_han_alltoall_using_smsc(
         low_comm->c_coll->coll_barrier(low_comm, low_comm->c_coll->coll_barrier_module);
     }
 
-    for (int jlow=0; jlow<low_size; jlow++) {
-        if (jlow != low_rank ) {
-            mca_smsc->unmap_peer_region(sbuf_map_ctx[jlow]);
+    if (mca_coll_han_component.han_use_persist_buffers) {
+        /* SMSC mappings, bounce, and arrays are cached — do not free/unmap */
+    } else {
+        for (int jlow=0; jlow<low_size; jlow++) {
+            if (jlow != low_rank) {
+                mca_smsc->unmap_peer_region(sbuf_map_ctx[jlow]);
+            }
         }
     }
     OBJ_DESTRUCT(&convertor);
     if (send_bounce_status == BOUNCE_IS_FROM_FREELIST) {
         opal_free_list_return(&mca_coll_han_component.pack_buffers, send_fl_item);
-    } else if (send_bounce_status == BOUNCE_IS_FROM_MALLOC) {
+    } else if (send_bounce_status == BOUNCE_IS_FROM_MALLOC
+               && !mca_coll_han_component.han_use_persist_buffers) {
         free(send_bounce);
     }
     free(inter_send_reqs);
     free(inter_recv_reqs);
-    free(sbuf_map_ctx);
-    free(low_bufs);
-    free(gather_buf_out);
+    if (!mca_coll_han_component.han_use_persist_buffers) {
+        free(sbuf_map_ctx);
+        free(low_bufs);
+        free(gather_buf_out);
+    }
 
     OPAL_OUTPUT_VERBOSE((40, mca_coll_han_component.han_output,
                 "Alltoall Complete with %d\n",rc));
diff --git a/ompi/mca/coll/han/coll_han_alltoallv.c b/ompi/mca/coll/han/coll_han_alltoallv.c
index b3c25014b2f..ad9c92892e9 100644
--- a/ompi/mca/coll/han/coll_han_alltoallv.c
+++ b/ompi/mca/coll/han/coll_han_alltoallv.c
@@ -582,6 +582,52 @@ static int alltoallv_sendrecv_w(
     return 0;
 }
 
+
+/**
+ * Set up persistent allocations for alltoallv.
+ * Grows arrays to high-water mark to avoid per-call malloc/free.
+ * Returns OMPI_SUCCESS on success, OMPI_ERR_OUT_OF_RESOURCE on failure.
+ */
+static int alltoallv_cache_setup(
+    struct han_alltoallv_cache *c,
+    size_t serialization_buf_length, int low_size)
+{
+    if (c->serial_buf_size < serialization_buf_length) {
+        free(c->serial_buf);
+        c->serial_buf = malloc(serialization_buf_length);
+        if (NULL == c->serial_buf) {
+            c->serial_buf_size = 0;
+            return OMPI_ERR_OUT_OF_RESOURCE;
+        }
+        c->serial_buf_size = serialization_buf_length;
+    }
+    if (c->low_size < low_size) {
+        free(c->gather_out);  free(c->peers);      free(c->peer_types);
+        free(c->send_from);   free(c->recv_to);
+        free(c->send_counts); free(c->recv_counts);
+        free(c->send_types);  free(c->recv_types);
+        c->low_size = 0;
+        c->gather_out  = malloc(sizeof(struct gathered_data) * low_size);
+        c->peers       = malloc(sizeof(struct peer_data) * low_size);
+        c->peer_types  = malloc(sizeof(opal_datatype_t) * low_size);
+        c->send_from   = malloc(sizeof(void*) * low_size);
+        c->recv_to     = malloc(sizeof(void*) * low_size);
+        c->send_counts = malloc(sizeof(size_t) * low_size);
+        c->recv_counts = malloc(sizeof(size_t) * low_size);
+        c->send_types  = malloc(sizeof(opal_datatype_t*) * low_size);
+        c->recv_types  = malloc(sizeof(opal_datatype_t*) * low_size);
+        if (NULL == c->gather_out || NULL == c->peers ||
+            NULL == c->peer_types || NULL == c->send_from ||
+            NULL == c->recv_to    || NULL == c->send_counts ||
+            NULL == c->recv_counts|| NULL == c->send_types ||
+            NULL == c->recv_types) {
+            return OMPI_ERR_OUT_OF_RESOURCE;
+        }
+        c->low_size = low_size;
+    }
+    return OMPI_SUCCESS;
+}
+
 static int decide_to_use_smsc_alg(
     int *use_smsc,
     const void *sbuf,
@@ -769,11 +815,30 @@ int mca_coll_han_alltoallv_using_smsc(
     int w_size = ompi_comm_size(comm);
 
     int use_smsc;
-    rc = decide_to_use_smsc_alg(&use_smsc,
-        sbuf, scounts, sdispls, sdtype, rbuf, rcounts, rdispls, rdtype, comm);
-    if (rc != 0) {
-        opal_output_verbose(1, mca_coll_han_component.han_output,
-            "decide_to_use_smsc_alg failed during execution! rc=%d\n", rc);
+    if (sbuf == MPI_IN_PLACE) {
+        return han_module->previous_alltoallv(sbuf, scounts, sdispls, sdtype, rbuf, rcounts, rdispls, rdtype,
+                                             comm, han_module->previous_alltoallv_module);
+    }
+
+    /* Cache the decide_to_use_smsc_alg result to avoid per-call allreduce.
+     * The first call runs the allreduce (all ranks participate). Every
+     * subsequent call reuses the cached result. This is safe because the
+     * decision depends on buffer types (GPU, contiguous) which don't change
+     * between calls, and the MCA parameter is globally consistent. */
+    if (mca_coll_han_component.han_use_persist_buffers
+        && han_module->a2av_cache.smsc_decided) {
+        use_smsc = han_module->a2av_cache.use_smsc;
+    } else {
+        rc = decide_to_use_smsc_alg(&use_smsc,
+            sbuf, scounts, sdispls, sdtype, rbuf, rcounts, rdispls, rdtype, comm);
+        if (rc != 0) {
+            opal_output_verbose(1, mca_coll_han_component.han_output,
+                "decide_to_use_smsc_alg failed during execution! rc=%d\n", rc);
+        }
+        if (mca_coll_han_component.han_use_persist_buffers) {
+            han_module->a2av_cache.smsc_decided = true;
+            han_module->a2av_cache.use_smsc = use_smsc;
+        }
     }
     if (!use_smsc) {
         return han_module->previous_alltoallv(sbuf, scounts, sdispls, sdtype, rbuf, rcounts, rdispls, rdtype,
@@ -790,22 +855,36 @@ int mca_coll_han_alltoallv_using_smsc(
     int up_rank = ompi_comm_rank(up_comm);
 
     struct gathered_data low_gather_in;
-    struct gathered_data *low_gather_out;
+    struct gathered_data *low_gather_out = NULL;
 
 
     low_gather_in.stype_serialized_length = ddt_pack_datatype(&sdtype->super, NULL);
-    uint8_t *serialization_buf;
+    uint8_t *serialization_buf = NULL;
 
     size_t serialization_buf_length = low_gather_in.stype_serialized_length
         + sizeof(struct peer_counts)*w_size;
 
-    /* allocate data */
-    serialization_buf = malloc(serialization_buf_length);
-    low_gather_out = malloc(sizeof(*low_gather_out) * low_size);
-    struct peer_data *peers = malloc(sizeof(*peers) * low_size);
-    opal_datatype_t *peer_send_types = malloc(sizeof(*peer_send_types) * low_size);
+    struct peer_data *peers = NULL;
+    opal_datatype_t *peer_send_types = NULL;
     bool have_bufs_and_types = false;
 
+    if (mca_coll_han_component.han_use_persist_buffers) {
+        /* Persistent allocations (realloc-to-HWM) */
+        rc = alltoallv_cache_setup(&han_module->a2av_cache,
+                                   serialization_buf_length, low_size);
+        if (rc != OMPI_SUCCESS) { goto cleanup; }
+        serialization_buf = han_module->a2av_cache.serial_buf;
+        low_gather_out = han_module->a2av_cache.gather_out;
+        peers = han_module->a2av_cache.peers;
+        peer_send_types = han_module->a2av_cache.peer_types;
+    } else {
+        /* Original upstream path — fresh allocations per call */
+        serialization_buf = malloc(serialization_buf_length);
+        low_gather_out = malloc(sizeof(*low_gather_out) * low_size);
+        peers = malloc(sizeof(*peers) * low_size);
+        peer_send_types = malloc(sizeof(*peer_send_types) * low_size);
+    }
+
     low_gather_in.serialization_buffer = serialization_buf;
     low_gather_in.sbuf = (void*)sbuf; // cast to discard the const
 
@@ -831,6 +910,7 @@ int mca_coll_han_alltoallv_using_smsc(
     buf_packed += ddt_pack_datatype(&sdtype->super, serialization_buf + buf_packed);
     assert(buf_packed == serialization_buf_length);
 
+    /* Always run allgather — all ranks must participate (collective) */
     rc = low_comm->c_coll->coll_allgather(&low_gather_in, sizeof(low_gather_in), MPI_BYTE,
             low_gather_out, sizeof(low_gather_in), MPI_BYTE, low_comm,
             low_comm->c_coll->coll_allgather_module);
@@ -898,12 +978,21 @@ int mca_coll_han_alltoallv_using_smsc(
     }
 
     have_bufs_and_types = true;
-    send_from_addrs = malloc(sizeof(*send_from_addrs)*low_size);
-    recv_to_addrs = malloc(sizeof(*recv_to_addrs)*low_size);
-    send_counts = malloc(sizeof(*send_counts)*low_size);
-    recv_counts = malloc(sizeof(*recv_counts)*low_size);
-    send_types = malloc(sizeof(*send_types)*low_size);
-    recv_types = malloc(sizeof(*recv_types)*low_size);
+    if (mca_coll_han_component.han_use_persist_buffers) {
+        send_from_addrs = han_module->a2av_cache.send_from;
+        recv_to_addrs = han_module->a2av_cache.recv_to;
+        send_counts = han_module->a2av_cache.send_counts;
+        recv_counts = han_module->a2av_cache.recv_counts;
+        send_types = (opal_datatype_t **)han_module->a2av_cache.send_types;
+        recv_types = (opal_datatype_t **)han_module->a2av_cache.recv_types;
+    } else {
+        send_from_addrs = malloc(sizeof(*send_from_addrs)*low_size);
+        recv_to_addrs = malloc(sizeof(*recv_to_addrs)*low_size);
+        send_counts = malloc(sizeof(*send_counts)*low_size);
+        recv_counts = malloc(sizeof(*recv_counts)*low_size);
+        send_types = malloc(sizeof(*send_types)*low_size);
+        recv_types = malloc(sizeof(*recv_types)*low_size);
+    }
 
     /****
      *  Main exchange loop
@@ -957,7 +1046,7 @@ int mca_coll_han_alltoallv_using_smsc(
     cleanup:
     low_comm->c_coll->coll_barrier(low_comm, low_comm->c_coll->coll_barrier_module);
 
-    if (send_from_addrs) {
+    if (send_from_addrs && !mca_coll_han_component.han_use_persist_buffers) {
         free(send_from_addrs);
         free(recv_to_addrs);
         free(send_counts);
@@ -971,7 +1060,6 @@ int mca_coll_han_alltoallv_using_smsc(
             if (jlow != low_rank) {
                 OBJ_DESTRUCT(&peer_send_types[jlow]);
             }
-
             for (int jbuf=0; jbuf<2; jbuf++) {
                 if (peers[jlow].map_ctx[jbuf]) {
                     mca_smsc->unmap_peer_region(peers[jlow].map_ctx[jbuf]);
@@ -979,10 +1067,12 @@ int mca_coll_han_alltoallv_using_smsc(
             }
         }
     }
-    free(serialization_buf);
-    free(low_gather_out);
-    free(peers);
-    free(peer_send_types);
+    if (!mca_coll_han_component.han_use_persist_buffers) {
+        free(serialization_buf);
+        free(low_gather_out);
+        free(peers);
+        free(peer_send_types);
+    }
 
     OPAL_OUTPUT_VERBOSE((40, mca_coll_han_component.han_output,
                 "Alltoall Complete with %d\n",rc));
diff --git a/ompi/mca/coll/han/coll_han_component.c b/ompi/mca/coll/han/coll_han_component.c
index 7ae17b9e4f8..9e7f1259feb 100644
--- a/ompi/mca/coll/han/coll_han_component.c
+++ b/ompi/mca/coll/han/coll_han_component.c
@@ -640,5 +640,32 @@ static int han_register(void)
                                            &(cs->max_dynamic_errors));
 
 
+    cs->han_use_persist_buffers = true;
+    (void) mca_base_component_var_register(&mca_coll_han_component.super.collm_version,
+                                           "use_persist_buffers",
+                                           "Use persistent/freelist buffers to avoid malloc/free in collectives (0 = disabled)",
+                                           MCA_BASE_VAR_TYPE_BOOL, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
+                                           OPAL_INFO_LVL_6,
+                                           MCA_BASE_VAR_SCOPE_ALL,
+                                           &(cs->han_use_persist_buffers));
+
+    cs->han_fragment_size = 65536;
+    (void) mca_base_component_var_register(&mca_coll_han_component.super.collm_version,
+                                           "fragment_size",
+                                           "Size of freelist fragment buffers for collective operations (0 = disabled)",
+                                           MCA_BASE_VAR_TYPE_UNSIGNED_LONG, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
+                                           OPAL_INFO_LVL_6,
+                                           MCA_BASE_VAR_SCOPE_ALL,
+                                           &(cs->han_fragment_size));
+
+    cs->han_large_fragment_size = 1048576;
+    (void) mca_base_component_var_register(&mca_coll_han_component.super.collm_version,
+                                           "large_fragment_size",
+                                           "Size of large freelist buffers for pipeline reorder (0 = use small fragments or malloc)",
+                                           MCA_BASE_VAR_TYPE_UNSIGNED_LONG, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE,
+                                           OPAL_INFO_LVL_6,
+                                           MCA_BASE_VAR_SCOPE_ALL,
+                                           &(cs->han_large_fragment_size));
+
     return OMPI_SUCCESS;
 }
diff --git a/ompi/mca/coll/han/coll_han_gather.c b/ompi/mca/coll/han/coll_han_gather.c
index e3259267b9a..63f98776b19 100644
--- a/ompi/mca/coll/han/coll_han_gather.c
+++ b/ompi/mca/coll/han/coll_han_gather.c
@@ -46,7 +46,8 @@ mca_coll_han_set_gather_args(mca_coll_han_gather_args_t * args,
                              int root_low_rank,
                              struct ompi_communicator_t *up_comm,
                              struct ompi_communicator_t *low_comm,
-                             int w_rank, bool noop, bool is_mapbycore, ompi_request_t * req)
+                             int w_rank, bool noop, bool is_mapbycore, ompi_request_t * req,
+                             mca_coll_han_module_t *han_module)
 {
     args->cur_task = cur_task;
     args->sbuf = sbuf;
@@ -65,6 +66,7 @@ mca_coll_han_set_gather_args(mca_coll_han_gather_args_t * args,
     args->noop = noop;
     args->is_mapbycore = is_mapbycore;
     args->req = req;
+    args->han_module = han_module;
 }
 
 
@@ -156,7 +158,11 @@ mca_coll_han_gather_intra(const void *sbuf, size_t scount,
             rsize = opal_datatype_span(&rdtype->super,
                                        (int64_t)rcount * w_size,
                                        &rgap);
-            reorder_buf = (char *)malloc(rsize);        //TODO:free
+            reorder_buf = han_scratch_or_malloc(&han_module->scratch_buf[0],
+                                                 &han_module->scratch_buf_size[0],
+                                                 (size_t)rsize,
+                                                 mca_coll_han_component.han_use_persist_buffers);
+            if (NULL == reorder_buf) return OMPI_ERR_OUT_OF_RESOURCE;
             /* rgap is the size of unused space at the start of the datatype */
             reorder_rbuf = reorder_buf - rgap;
 
@@ -180,7 +186,8 @@ mca_coll_han_gather_intra(const void *sbuf, size_t scount,
     mca_coll_han_gather_args_t *lg_args = malloc(sizeof(mca_coll_han_gather_args_t));
     mca_coll_han_set_gather_args(lg_args, lg, (char *) sbuf, NULL, scount, sdtype, reorder_rbuf,
                                  rcount, rdtype, root, root_up_rank, root_low_rank, up_comm,
-                                 low_comm, w_rank, low_rank != root_low_rank, han_module->is_mapbycore, temp_request);
+                                 low_comm, w_rank, low_rank != root_low_rank, han_module->is_mapbycore, temp_request,
+                                 han_module);
     /* Init lg task */
     init_task(lg, mca_coll_han_gather_lg_task, (void *) (lg_args));
     /* Issure lg task */
@@ -193,7 +200,9 @@ mca_coll_han_gather_intra(const void *sbuf, size_t scount,
         ompi_coll_han_reorder_gather(reorder_buf,
                                      rbuf, rcount, rdtype,
                                      comm, topo);
-        free(reorder_buf);
+        if (!mca_coll_han_component.han_use_persist_buffers) {
+            free(reorder_buf);
+        }
     }
 
     return OMPI_SUCCESS;
@@ -212,15 +221,18 @@ int mca_coll_han_gather_lg_task(void *task_args)
     char *tmp_buf = NULL;
     char *tmp_rbuf = NULL;
     if (!t->noop) {
-        /* if the process is one of the node leader, allocate the intermediary
-         * buffer to gather on the low sub communicator */
+        /* Intra-node gather buffer: persistent realloc-to-HWM or malloc */
         int low_size = ompi_comm_size(t->low_comm);
         int low_rank = ompi_comm_rank(t->low_comm);
         ptrdiff_t rsize, rgap = 0;
         rsize = opal_datatype_span(&dtype->super,
                                    count * low_size,
                                    &rgap);
-        tmp_buf = (char *) malloc(rsize);
+        tmp_buf = han_scratch_or_malloc(&t->han_module->scratch_buf[1],
+                                        &t->han_module->scratch_buf_size[1],
+                                        (size_t)rsize,
+                                        mca_coll_han_component.han_use_persist_buffers);
+        if (NULL == tmp_buf) return OMPI_ERR_OUT_OF_RESOURCE;
         tmp_rbuf = tmp_buf - rgap;
         if (t->w_rank == t->root && MPI_IN_PLACE == t->sbuf) {
             ptrdiff_t rextent;
@@ -286,9 +298,12 @@ int mca_coll_han_gather_ug_task(void *task_args)
                                         t->up_comm,
                                         t->up_comm->c_coll->coll_gather_module);
 
-        if (t->sbuf_inter_free != NULL) {
-            free(t->sbuf_inter_free);
-            t->sbuf_inter_free = NULL;
+        /* Free intra-node buffer when not using persist buffers */
+        if (!mca_coll_han_component.han_use_persist_buffers) {
+            if (t->sbuf_inter_free != NULL) {
+                free(t->sbuf_inter_free);
+                t->sbuf_inter_free = NULL;
+            }
         }
         OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
                              "[%d] Han Gather:  ug gather finish\n", t->w_rank));
@@ -371,23 +386,30 @@ mca_coll_han_gather_intra_simple(const void *sbuf, size_t scount,
             ptrdiff_t rsize = opal_datatype_span(&rdtype->super,
                                                  (int64_t)rcount * w_size,
                                                  &rgap);
-            reorder_buf = (char *)malloc(rsize);
+            reorder_buf = han_scratch_or_malloc(&han_module->scratch_buf[0],
+                                                 &han_module->scratch_buf_size[0],
+                                                 (size_t)rsize,
+                                                 mca_coll_han_component.han_use_persist_buffers);
+            if (NULL == reorder_buf) return OMPI_ERR_OUT_OF_RESOURCE;
             /* rgap is the size of unused space at the start of the datatype */
             reorder_buf_start = reorder_buf - rgap;
         }
 
     }
 
-    /* allocate the intermediary buffer
-     * to gather on leaders on the low sub communicator */
-    char *tmp_buf = NULL; // allocated memory
-    char *tmp_buf_start = NULL; // start of the data
+    /* Intra-node gather buffer: persistent realloc-to-HWM or malloc */
+    char *tmp_buf = NULL;
+    char *tmp_buf_start = NULL;
     if (low_rank == root_low_rank) {
         ptrdiff_t rsize, rgap = 0;
         rsize = opal_datatype_span(&dtype->super,
                                    count * low_size,
                                    &rgap);
-        tmp_buf = (char *) malloc(rsize);
+        tmp_buf = han_scratch_or_malloc(&han_module->scratch_buf[1],
+                                        &han_module->scratch_buf_size[1],
+                                        (size_t)rsize,
+                                        mca_coll_han_component.han_use_persist_buffers);
+        if (NULL == tmp_buf) return OMPI_ERR_OUT_OF_RESOURCE;
         tmp_buf_start = tmp_buf - rgap;
     }
 
@@ -414,10 +436,10 @@ mca_coll_han_gather_intra_simple(const void *sbuf, size_t scount,
                                      up_comm,
                                      up_comm->c_coll->coll_gather_module);
 
-        if (tmp_buf != NULL) {
+        /* Free intra-node buffer when not using persist buffers */
+        if (!mca_coll_han_component.han_use_persist_buffers) {
             free(tmp_buf);
             tmp_buf = NULL;
-            tmp_buf_start = NULL;
         }
         OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
                              "[%d] Future Gather:  ug gather finish\n", w_rank));
@@ -431,7 +453,9 @@ mca_coll_han_gather_intra_simple(const void *sbuf, size_t scount,
         ompi_coll_han_reorder_gather(reorder_buf_start,
                                      rbuf, rcount, rdtype,
                                      comm, topo);
-        free(reorder_buf);
+        if (!mca_coll_han_component.han_use_persist_buffers) {
+            free(reorder_buf);
+        }
     }
 
     return OMPI_SUCCESS;
@@ -452,7 +476,7 @@ ompi_coll_han_reorder_gather(const void *sbuf,
                              void *rbuf, size_t count,
                              struct ompi_datatype_t *dtype,
                              struct ompi_communicator_t *comm,
-                             int * topo)
+                             const int * topo)
 {
     int i, topolevel = 2; // always 2 levels in topo
 #if OPAL_ENABLE_DEBUG
diff --git a/ompi/mca/coll/han/coll_han_gatherv.c b/ompi/mca/coll/han/coll_han_gatherv.c
index fd600b9d1cd..cf62870bcf0 100644
--- a/ompi/mca/coll/han/coll_han_gatherv.c
+++ b/ompi/mca/coll/han/coll_han_gatherv.c
@@ -219,7 +219,10 @@ int mca_coll_han_gatherv_intra(const void *sbuf, size_t scount, struct ompi_data
         if (need_bounce_buf) {
             ptrdiff_t rsize, rgap;
             rsize = opal_datatype_span(&rdtype->super, total_up_rcounts, &rgap);
-            bounce_buf = malloc(rsize);
+            bounce_buf = han_scratch_or_malloc(
+                &han_module->scratch_buf[0],
+                &han_module->scratch_buf_size[0],
+                rsize, mca_coll_han_component.han_use_persist_buffers);
             if (!bounce_buf) {
                 err = OMPI_ERR_OUT_OF_RESOURCE;
                 goto root_out;
@@ -276,7 +279,7 @@ int mca_coll_han_gatherv_intra(const void *sbuf, size_t scount, struct ompi_data
         if (up_peer_ub) {
             free(up_peer_ub);
         }
-        if (bounce_buf) {
+        if (bounce_buf && !mca_coll_han_component.han_use_persist_buffers) {
             free(bounce_buf);
         }
 
@@ -338,7 +341,10 @@ int mca_coll_han_gatherv_intra(const void *sbuf, size_t scount, struct ompi_data
         total_rsize += low_rcounts[i];
     }
 
-    tmp_buf = (char *) malloc(total_rsize); /* tmp_buf is still valid if total_rsize is 0 */
+    tmp_buf = han_scratch_or_malloc(
+        &han_module->scratch_buf[1],
+        &han_module->scratch_buf_size[1],
+        total_rsize, mca_coll_han_component.han_use_persist_buffers);
     if (!tmp_buf) {
         err = OMPI_ERR_OUT_OF_RESOURCE;
         goto node_leader_out;
@@ -363,7 +369,7 @@ int mca_coll_han_gatherv_intra(const void *sbuf, size_t scount, struct ompi_data
     if (low_displs) {
         free(low_displs);
     }
-    if (tmp_buf) {
+    if (tmp_buf && !mca_coll_han_component.han_use_persist_buffers) {
         free(tmp_buf);
     }
 
diff --git a/ompi/mca/coll/han/coll_han_module.c b/ompi/mca/coll/han/coll_han_module.c
index 28338439e39..2ea27325728 100644
--- a/ompi/mca/coll/han/coll_han_module.c
+++ b/ompi/mca/coll/han/coll_han_module.c
@@ -7,7 +7,7 @@
  * Copyright (c) 2021      Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2022      IBM Corporation. All rights reserved
- * Copyright (c) 2024      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2024-2026 NVIDIA Corporation.  All rights reserved.
  * Copyright (c) 2024      Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * $COPYRIGHT$
  *
@@ -22,6 +22,131 @@
 #include "coll_han.h"
 #include "coll_han_dynamic.h"
 
+/*
+ * Fragment item class for freelist-based buffer pool (64KB)
+ */
+static void fragment_item_constructor(fragment_item_t *item)
+{
+    item->buffer = NULL;
+    if (mca_coll_han_component.han_fragment_size > 0) {
+        if (posix_memalign(&item->buffer, 4096, mca_coll_han_component.han_fragment_size) != 0) {
+            item->buffer = NULL;
+        }
+    }
+}
+
+static void fragment_item_destructor(fragment_item_t *item)
+{
+    if (item->buffer) {
+        free(item->buffer);
+        item->buffer = NULL;
+    }
+}
+
+OBJ_CLASS_INSTANCE(fragment_item_t,
+                   opal_free_list_item_t,
+                   fragment_item_constructor,
+                   fragment_item_destructor);
+
+/*
+ * Large fragment item class for freelist-based buffer pool (1MB)
+ */
+static void large_fragment_item_constructor(large_fragment_item_t *item)
+{
+    item->buffer = NULL;
+    if (mca_coll_han_component.han_large_fragment_size > 0) {
+        if (posix_memalign(&item->buffer, 4096, mca_coll_han_component.han_large_fragment_size) != 0) {
+            item->buffer = NULL;
+        }
+    }
+}
+
+static void large_fragment_item_destructor(large_fragment_item_t *item)
+{
+    if (item->buffer) {
+        free(item->buffer);
+        item->buffer = NULL;
+    }
+}
+
+OBJ_CLASS_INSTANCE(large_fragment_item_t,
+                   opal_free_list_item_t,
+                   large_fragment_item_constructor,
+                   large_fragment_item_destructor);
+
+/**
+ * Initialize fragment freelists on a HAN module.
+ */
+#define HAN_FRAG_INITIAL_COUNT   32
+#define HAN_FRAG_MAX_COUNT       (-1)  /* unlimited */
+#define HAN_FRAG_GROWTH_BATCH    64
+#define HAN_LARGE_FRAG_INITIAL    4
+#define HAN_LARGE_FRAG_MAX       20
+#define HAN_LARGE_FRAG_GROWTH     4
+
+static void han_init_freelists(mca_coll_han_module_t *han_module)
+{
+    int rc;
+    if (!mca_coll_han_component.han_use_persist_buffers) {
+        return;
+    }
+    if (mca_coll_han_component.han_fragment_size > 0) {
+        OBJ_CONSTRUCT(&han_module->fragment_freelist, opal_free_list_t);
+        rc = opal_free_list_init(&han_module->fragment_freelist,
+                            sizeof(fragment_item_t),
+                            opal_cache_line_size,
+                            OBJ_CLASS(fragment_item_t),
+                            0, opal_cache_line_size,
+                            HAN_FRAG_INITIAL_COUNT,
+                            HAN_FRAG_MAX_COUNT,
+                            HAN_FRAG_GROWTH_BATCH,
+                            NULL, 0, NULL, NULL, NULL);
+        if (OPAL_SUCCESS != rc) {
+            OBJ_DESTRUCT(&han_module->fragment_freelist);
+            opal_output_verbose(0, mca_coll_han_component.han_output,
+                "coll:han: fragment freelist init failed, disabling persist buffers\n");
+            mca_coll_han_component.han_use_persist_buffers = false;
+            return;
+        }
+    }
+    OBJ_CONSTRUCT(&han_module->large_fragment_freelist, opal_free_list_t);
+    if (mca_coll_han_component.han_large_fragment_size > 0) {
+        rc = opal_free_list_init(&han_module->large_fragment_freelist,
+                            sizeof(large_fragment_item_t),
+                            opal_cache_line_size,
+                            OBJ_CLASS(large_fragment_item_t),
+                            0, opal_cache_line_size,
+                            HAN_LARGE_FRAG_INITIAL,
+                            HAN_LARGE_FRAG_MAX,
+                            HAN_LARGE_FRAG_GROWTH,
+                            NULL, 0, NULL, NULL, NULL);
+        if (OPAL_SUCCESS != rc) {
+            OBJ_DESTRUCT(&han_module->large_fragment_freelist);
+            if (mca_coll_han_component.han_fragment_size > 0) {
+                OBJ_DESTRUCT(&han_module->fragment_freelist);
+            }
+            opal_output_verbose(0, mca_coll_han_component.han_output,
+                "coll:han: large fragment freelist init failed, disabling persist buffers\n");
+            mca_coll_han_component.han_use_persist_buffers = false;
+            return;
+        }
+    }
+}
+
+/**
+ * Destroy fragment freelists on a HAN module.
+ */
+static void han_destroy_freelists(mca_coll_han_module_t *han_module)
+{
+    if (!mca_coll_han_component.han_use_persist_buffers) {
+        return;
+    }
+    if (mca_coll_han_component.han_fragment_size > 0) {
+        OBJ_DESTRUCT(&han_module->fragment_freelist);
+    }
+    OBJ_DESTRUCT(&han_module->large_fragment_freelist);
+}
+
 
 /*
  *@file
@@ -80,6 +205,12 @@ static void mca_coll_han_module_construct(mca_coll_han_module_t * module)
     module->cached_up_comms = NULL;
     module->cached_vranks = NULL;
     module->cached_topo = NULL;
+    module->scratch_buf[0] = NULL;
+    module->scratch_buf_size[0] = 0;
+    module->scratch_buf[1] = NULL;
+    module->scratch_buf_size[1] = 0;
+    memset(&module->a2a_cache, 0, sizeof(module->a2a_cache));
+    memset(&module->a2av_cache, 0, sizeof(module->a2av_cache));
     module->is_mapbycore = false;
     module->storage_initialized = false;
     for( i = 0; i < NB_TOPO_LVL; i++ ) {
@@ -116,7 +247,12 @@ mca_coll_han_module_destruct(mca_coll_han_module_t * module)
 
     if (module->cached_low_comms != NULL) {
         for (i = 0; i < COLL_HAN_LOW_MODULES; i++) {
+            int cid = module->cached_low_comms[i]->c_index;
             ompi_comm_free(&(module->cached_low_comms[i]));
+            ompi_communicator_t *tmp = ompi_comm_lookup(cid);
+            if (NULL != tmp) {
+                OBJ_RELEASE(tmp);
+            }
             module->cached_low_comms[i] = NULL;
         }
         free(module->cached_low_comms);
@@ -124,7 +260,12 @@ mca_coll_han_module_destruct(mca_coll_han_module_t * module)
     }
     if (module->cached_up_comms != NULL) {
         for (i = 0; i < COLL_HAN_UP_MODULES; i++) {
+            int cid = module->cached_up_comms[i]->c_index;
             ompi_comm_free(&(module->cached_up_comms[i]));
+            ompi_communicator_t *tmp = ompi_comm_lookup(cid);
+            if (NULL != tmp) {
+                OBJ_RELEASE(tmp);
+            }
             module->cached_up_comms[i] = NULL;
         }
         free(module->cached_up_comms);
@@ -138,9 +279,48 @@ mca_coll_han_module_destruct(mca_coll_han_module_t * module)
         free(module->cached_topo);
         module->cached_topo = NULL;
     }
+    free(module->scratch_buf[0]);
+    module->scratch_buf[0] = NULL;
+    module->scratch_buf_size[0] = 0;
+    free(module->scratch_buf[1]);
+    module->scratch_buf[1] = NULL;
+    module->scratch_buf_size[1] = 0;
+
+    /* Alltoall cache cleanup */
+    free(module->a2a_cache.bounce);
+    if (module->a2a_cache.map_ctx) {
+        if (mca_smsc) {
+            for (i = 0; i < module->a2a_cache.cached_low_size; i++) {
+                if (module->a2a_cache.map_ctx[i])
+                    mca_smsc->unmap_peer_region(module->a2a_cache.map_ctx[i]);
+            }
+        }
+        free(module->a2a_cache.map_ctx);
+    }
+    free(module->a2a_cache.low_bufs);
+    free(module->a2a_cache.gather_buf);
+    free(module->a2a_cache.recv_buf);
+
+    /* Alltoallv cache cleanup */
+    free(module->a2av_cache.serial_buf);
+    free(module->a2av_cache.gather_out);
+    free(module->a2av_cache.peers);
+    free(module->a2av_cache.peer_types);
+    free(module->a2av_cache.send_from);
+    free(module->a2av_cache.recv_to);
+    free(module->a2av_cache.send_counts);
+    free(module->a2av_cache.recv_counts);
+    free(module->a2av_cache.send_types);
+    free(module->a2av_cache.recv_types);
+
     for(i=0 ; i<NB_TOPO_LVL ; i++) {
         if(NULL != module->sub_comm[i]) {
+            int cid = module->sub_comm[i]->c_index;
             ompi_comm_free(&(module->sub_comm[i]));
+            ompi_communicator_t *tmp = ompi_comm_lookup(cid);
+            if (NULL != tmp) {
+                OBJ_RELEASE(tmp);
+            }
         }
     }
 
@@ -300,6 +480,8 @@ mca_coll_han_module_enable(mca_coll_base_module_t * module,
 {
     mca_coll_han_module_t * han_module = (mca_coll_han_module_t*) module;
 
+    han_init_freelists(han_module);
+
     HAN_INSTALL_COLL_API(comm, han_module, alltoall);
     HAN_INSTALL_COLL_API(comm, han_module, alltoallv);
     HAN_INSTALL_COLL_API(comm, han_module, allgather);
@@ -329,6 +511,8 @@ mca_coll_han_module_disable(mca_coll_base_module_t * module,
 {
     mca_coll_han_module_t * han_module = (mca_coll_han_module_t *) module;
 
+    han_destroy_freelists(han_module);
+
     HAN_UNINSTALL_COLL_API(comm, han_module, alltoall);
     HAN_UNINSTALL_COLL_API(comm, han_module, alltoallv);
     HAN_UNINSTALL_COLL_API(comm, han_module, allgather);
diff --git a/ompi/mca/coll/han/coll_han_reduce.c b/ompi/mca/coll/han/coll_han_reduce.c
index 097da6e7662..40e038fcd02 100644
--- a/ompi/mca/coll/han/coll_han_reduce.c
+++ b/ompi/mca/coll/han/coll_han_reduce.c
@@ -143,17 +143,16 @@ mca_coll_han_reduce_intra(const void *sbuf,
 
     /* node leaders require a buffer to store intermediate results */
     void *tmp_rbuf = NULL;
-    void *tmp_rbuf_to_free = NULL;
+    bool is_tmp_rbuf = false;
     if (w_rank == root) {
         /* the global root already has one */
         tmp_rbuf = rbuf;
     } else if (low_rank == root_low_rank) {
         /* allocate 2 temporary segments on node leaders that are not the global root */
-        tmp_rbuf = malloc(2*extent*seg_count);
-        if (NULL == tmp_rbuf) {
-            return OMPI_ERR_OUT_OF_RESOURCE;
-        }
-        tmp_rbuf_to_free = tmp_rbuf;
+        size_t needed = 2*extent*seg_count;
+        tmp_rbuf = malloc(needed);
+        if (NULL == tmp_rbuf) return OMPI_ERR_OUT_OF_RESOURCE;
+        is_tmp_rbuf = true;
     }
 
     /* Create t0 tasks for the first segment */
@@ -163,7 +162,7 @@ mca_coll_han_reduce_intra(const void *sbuf,
     mca_coll_han_set_reduce_args(t, t0, (char *) sbuf, (char *) tmp_rbuf, seg_count, dtype,
                                  op, root_up_rank, root_low_rank, up_comm, low_comm,
                                  num_segments, 0, w_rank, count - (num_segments - 1) * seg_count,
-                                 low_rank != root_low_rank, (NULL != tmp_rbuf_to_free));
+                                 low_rank != root_low_rank, is_tmp_rbuf);
     /* Init the first task */
     init_task(t0, mca_coll_han_reduce_t0_task, (void *) t);
     issue_task(t0);
@@ -195,7 +194,9 @@ mca_coll_han_reduce_intra(const void *sbuf,
     }
 
     free(t);
-    free(tmp_rbuf_to_free);
+    if (is_tmp_rbuf) {
+        free(tmp_rbuf);
+    }
 
     return OMPI_SUCCESS;
 
@@ -296,7 +297,8 @@ mca_coll_han_reduce_intra_simple(const void *sbuf,
     int ret;
     int *vranks, low_rank, low_size;
     ptrdiff_t rsize, rgap = 0;
-    void * tmp_buf;
+    void * tmp_buf = NULL;
+    opal_free_list_item_t *tmp_fl_item = NULL;
 
     mca_coll_han_module_t *han_module = (mca_coll_han_module_t *)module;
 
@@ -345,11 +347,25 @@ mca_coll_han_reduce_intra_simple(const void *sbuf,
     /* Get root ranks for low and up comms */
     mca_coll_han_get_ranks(vranks, root, low_size, &root_low_rank, &root_up_rank);
 
+    /* Freelist-backed simple reduce: low_comm reduce → up_comm reduce */
     if (root_low_rank == low_rank && w_rank != root) {
         rsize = opal_datatype_span(&dtype->super, (int64_t)count, &rgap);
-        tmp_buf = malloc(rsize);
-        if (NULL == tmp_buf) {
-            return OMPI_ERROR;
+        if (mca_coll_han_component.han_use_persist_buffers) {
+            size_t frag_size = mca_coll_han_component.han_fragment_size;
+            if (frag_size > 0 && (size_t)rsize <= frag_size) {
+                fragment_item_t *fi = (fragment_item_t*)opal_free_list_get(
+                                          &han_module->fragment_freelist);
+                if (fi != NULL) {
+                    tmp_buf = (char *)fi->buffer;
+                    tmp_fl_item = (opal_free_list_item_t*)fi;
+                }
+            }
+        }
+        if (tmp_buf == NULL) {
+            tmp_buf = malloc(rsize);
+            if (NULL == tmp_buf) {
+                return OMPI_ERROR;
+            }
         }
     } else {
         /* global root rbuf is valid, local non-root do not need buffers */
@@ -364,7 +380,11 @@ mca_coll_han_reduce_intra_simple(const void *sbuf,
                 low_comm, low_comm->c_coll->coll_reduce_module);
     if (OPAL_UNLIKELY(OMPI_SUCCESS != ret)){
         if (root_low_rank == low_rank && w_rank != root){
-            free(tmp_buf);
+            if (tmp_fl_item != NULL) {
+                opal_free_list_return(&han_module->fragment_freelist, tmp_fl_item);
+            } else {
+                free(tmp_buf);
+            }
         }
         OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
                              "HAN/REDUCE: low comm reduce failed. "
@@ -378,7 +398,11 @@ mca_coll_han_reduce_intra_simple(const void *sbuf,
             ret = up_comm->c_coll->coll_reduce((char *)tmp_buf, NULL,
                         count, dtype, op, root_up_rank,
                         up_comm, up_comm->c_coll->coll_reduce_module);
-            free(tmp_buf);
+            if (tmp_fl_item != NULL) {
+                opal_free_list_return(&han_module->fragment_freelist, tmp_fl_item);
+            } else {
+                free(tmp_buf);
+            }
         } else {
             /* Take advantage of any optimisation made for IN_PLACE
              * communications */
diff --git a/ompi/mca/coll/han/coll_han_scatter.c b/ompi/mca/coll/han/coll_han_scatter.c
index 2122103a5dd..65e5fae349e 100644
--- a/ompi/mca/coll/han/coll_han_scatter.c
+++ b/ompi/mca/coll/han/coll_han_scatter.c
@@ -4,6 +4,8 @@
  *                         reserved.
  * Copyright (c) 2022      IBM Corporation. All rights reserved
  * Copyright (c) 2024      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2026      Amazon.com, Inc. or its affiliates.
+ *                         All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,6 +28,51 @@
 static int mca_coll_han_scatter_us_task(void *task_args);
 static int mca_coll_han_scatter_ls_task(void *task_args);
 
+/**
+ * Allocate from tiered freelists (large then small), falling back to malloc.
+ */
+static char *scatter_alloc_tiered(opal_free_list_t *large_fl, size_t large_size,
+                                  opal_free_list_t *small_fl, size_t small_size,
+                                  size_t needed, opal_free_list_item_t **item,
+                                  int *src)
+{
+    *item = NULL;
+    *src = HAN_ALLOC_MALLOC;
+    if (large_size > 0 && needed <= large_size) {
+        large_fragment_item_t *lfi = (large_fragment_item_t *)opal_free_list_get(large_fl);
+        if (lfi != NULL) {
+            *item = (opal_free_list_item_t *)lfi;
+            *src = HAN_ALLOC_LARGE;
+            return (char *)lfi->buffer;
+        }
+    }
+    if (small_size > 0 && needed <= small_size) {
+        fragment_item_t *fi = (fragment_item_t *)opal_free_list_get(small_fl);
+        if (fi != NULL) {
+            *item = (opal_free_list_item_t *)fi;
+            *src = HAN_ALLOC_SMALL;
+            return (char *)fi->buffer;
+        }
+    }
+    return (char *)malloc(needed);
+}
+
+/**
+ * Free a tiered allocation based on src tag.
+ */
+static void scatter_free_tiered(opal_free_list_t *large_fl,
+                                opal_free_list_t *small_fl,
+                                opal_free_list_item_t *item, char *buf, int src)
+{
+    if (src == HAN_ALLOC_LARGE) {
+        opal_free_list_return(large_fl, item);
+    } else if (src == HAN_ALLOC_SMALL) {
+        opal_free_list_return(small_fl, item);
+    } else {
+        free(buf);
+    }
+}
+
 /* Only work with regular situation (each node has equal number of processes) */
 
 static inline void
@@ -44,7 +91,8 @@ mca_coll_han_set_scatter_args(mca_coll_han_scatter_args_t * args,
                               int root_low_rank,
                               struct ompi_communicator_t *up_comm,
                               struct ompi_communicator_t *low_comm,
-                              int w_rank, bool noop, ompi_request_t * req)
+                              int w_rank, bool noop, ompi_request_t * req,
+                              mca_coll_han_module_t *han_module)
 {
     args->cur_task = cur_task;
     args->sbuf = sbuf;
@@ -63,6 +111,9 @@ mca_coll_han_set_scatter_args(mca_coll_han_scatter_args_t * args,
     args->w_rank = w_rank;
     args->noop = noop;
     args->req = req;
+    args->han_module = han_module;
+    args->reorder_fl_item = NULL;
+    args->reorder_fl_src = HAN_ALLOC_MALLOC;
 }
 
 /*
@@ -138,6 +189,8 @@ mca_coll_han_scatter_intra(const void *sbuf, size_t scount,
      */
     char *reorder_buf = NULL;
     char *reorder_sbuf = NULL;
+    opal_free_list_item_t *reorder_fl_item = NULL;
+    int reorder_fl_src = HAN_ALLOC_MALLOC;
 
     if (w_rank == root) {
         /* If the processes are mapped-by core, no need to reorder */
@@ -149,7 +202,19 @@ mca_coll_han_scatter_intra(const void *sbuf, size_t scount,
             ptrdiff_t ssize, sgap = 0, sextent;
             ompi_datatype_type_extent(sdtype, &sextent);
             ssize = opal_datatype_span(&sdtype->super, (int64_t) scount * w_size, &sgap);
-            reorder_buf = (char *) malloc(ssize);
+            if (mca_coll_han_component.han_use_persist_buffers) {
+                reorder_buf = scatter_alloc_tiered(
+                    &han_module->large_fragment_freelist,
+                    mca_coll_han_component.han_large_fragment_size,
+                    &han_module->fragment_freelist,
+                    mca_coll_han_component.han_fragment_size,
+                    ssize, &reorder_fl_item, &reorder_fl_src);
+            } else {
+                reorder_buf = (char *)malloc(ssize);
+            }
+            if (NULL == reorder_buf) {
+                return OMPI_ERR_OUT_OF_RESOURCE;
+            }
             reorder_sbuf = reorder_buf - sgap;
             for (int i = 0; i < up_size; i++) {
                 for (int j = 0; j < low_size; j++) {
@@ -177,7 +242,9 @@ mca_coll_han_scatter_intra(const void *sbuf, size_t scount,
     mca_coll_han_set_scatter_args(us_args, us, reorder_sbuf, NULL, reorder_buf, scount, sdtype,
                                   (char *) rbuf, rcount, rdtype, root, root_up_rank, root_low_rank,
                                   up_comm, low_comm, w_rank, low_rank != root_low_rank,
-                                  temp_request);
+                                  temp_request, han_module);
+    us_args->reorder_fl_item = reorder_fl_item;
+    us_args->reorder_fl_src = reorder_fl_src;
     /* Init us task */
     init_task(us, mca_coll_han_scatter_us_task, (void *) (us_args));
     /* Issure us task */
@@ -209,8 +276,16 @@ int mca_coll_han_scatter_us_task(void *task_args)
         int low_size = ompi_comm_size(t->low_comm);
         ptrdiff_t rsize, rgap = 0;
         rsize = opal_datatype_span(&dtype->super, (int64_t) count * low_size, &rgap);
-        char *tmp_buf = (char *) malloc(rsize);
+
+        /* Inter-node receive buffer: persistent realloc-to-HWM or malloc */
+        char *tmp_buf;
+        tmp_buf = han_scratch_or_malloc(&t->han_module->scratch_buf[1],
+                                        &t->han_module->scratch_buf_size[1],
+                                        (size_t)rsize,
+                                        mca_coll_han_component.han_use_persist_buffers);
+        if (NULL == tmp_buf) return OMPI_ERR_OUT_OF_RESOURCE;
         char *tmp_rbuf = tmp_buf - rgap;
+
         OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
                              "[%d] Han Scatter:  us scatter\n", t->w_rank));
         /* Inter node scatter */
@@ -223,9 +298,18 @@ int mca_coll_han_scatter_us_task(void *task_args)
         t->scount = count;
     }
 
+    /* Free reorder buffer (root only) */
     if (t->sbuf_reorder_free != NULL && t->root == t->w_rank) {
-        free(t->sbuf_reorder_free);
+        if (mca_coll_han_component.han_use_persist_buffers) {
+            scatter_free_tiered(&t->han_module->large_fragment_freelist,
+                                &t->han_module->fragment_freelist,
+                                t->reorder_fl_item, t->sbuf_reorder_free,
+                                t->reorder_fl_src);
+        } else {
+            free(t->sbuf_reorder_free);
+        }
         t->sbuf_reorder_free = NULL;
+        t->reorder_fl_item = NULL;
     }
     /* Create ls tasks for the current union segment */
     mca_coll_task_t *ls = t->cur_task;
@@ -249,9 +333,12 @@ int mca_coll_han_scatter_ls_task(void *task_args)
                                       t->rcount, t->rdtype, t->root_low_rank, t->low_comm,
                                       t->low_comm->c_coll->coll_scatter_module);
 
-    if (t->sbuf_inter_free != NULL && t->noop != true) {
-        free(t->sbuf_inter_free);
-        t->sbuf_inter_free = NULL;
+    /* Free inter-node buffer when not using persist buffers */
+    if (!mca_coll_han_component.han_use_persist_buffers) {
+        if (t->sbuf_inter_free != NULL && !t->noop) {
+            free(t->sbuf_inter_free);
+            t->sbuf_inter_free = NULL;
+        }
     }
     OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output, "[%d] Han Scatter:  ls finish\n",
                          t->w_rank));
@@ -308,7 +395,7 @@ mca_coll_han_scatter_intra_simple(const void *sbuf, size_t scount,
     int low_rank = ompi_comm_rank(low_comm);
     int low_size = ompi_comm_size(low_comm);
     /* Get root ranks for low and up comms */
-    int root_low_rank, root_up_rank; /* root ranks for both sub-communicators */
+    int root_low_rank, root_up_rank;
     mca_coll_han_get_ranks(vranks, root, low_size, &root_low_rank, &root_up_rank);
 
     if (w_rank == root) {
@@ -323,7 +410,8 @@ mca_coll_han_scatter_intra_simple(const void *sbuf, size_t scount,
      * if the processes are mapped-by core, no need to reorder:
      * distribution of ranks on core first and node next,
      * in a increasing order for both patterns */
-    char *reorder_buf = NULL;  // allocated memory
+    char *reorder_buf = NULL;
+    bool reorder_is_sbuf = false;
     size_t block_size;
 
     ompi_datatype_type_size(dtype, &block_size);
@@ -337,23 +425,19 @@ mca_coll_han_scatter_intra_simple(const void *sbuf, size_t scount,
             OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
                                  "[%d]: Han scatter: no need to reorder: ", w_rank));
             reorder_buf = (char *)sbuf;
+            reorder_is_sbuf = true;
         } else {
             /* Data must be copied, let's be efficient packing it */
             OPAL_OUTPUT_VERBOSE((30, mca_coll_han_component.han_output,
                                  "[%d]: Han scatter: needs reordering or compacting: ", w_rank));
 
-            reorder_buf = malloc(block_size * w_size);
-            if ( NULL == reorder_buf){
-                return OMPI_ERROR;
-            }
+            size_t reorder_size = (size_t)block_size * w_size;
+            reorder_buf = han_scratch_or_malloc(&han_module->scratch_buf[0],
+                                                 &han_module->scratch_buf_size[0],
+                                                 reorder_size,
+                                                 mca_coll_han_component.han_use_persist_buffers);
+            if (NULL == reorder_buf) return OMPI_ERROR;
 
-            /** Reorder and packing:
-             * Suppose, the message is 0 1 2 3 4 5 6 7 but the processes are
-             * mapped on 2 nodes, for example |0 2 4 6| |1 3 5 7|. The messages to
-             * leaders must be 0 2 4 6 and 1 3 5 7.
-             * So the upper scatter must send 0 2 4 6 1 3 5 7.
-             * In general, the topo[i*topolevel +1]  must be taken.
-             */
             ptrdiff_t extent, block_extent;
             ompi_datatype_type_extent(dtype, &extent);
             block_extent = extent * (ptrdiff_t)count;
@@ -367,43 +451,74 @@ mca_coll_han_scatter_intra_simple(const void *sbuf, size_t scount,
         }
     }
 
-    /* allocate the intermediary buffer
-     * to scatter from leaders on the low sub communicators */
-    char *tmp_buf = NULL; // allocated memory
+    /*
+     * Persistent inter-node receive buffer.
+     * Grows to high-water mark via realloc so the virtual address
+     * stabilises after the first large call, keeping the NIC MR cache
+     * entry valid across iterations.
+     *
+     * When the total fits in a freelist item, use the freelist instead
+     * (the item address is also stable across get/return cycles).
+     */
+    size_t tmp_total = block_size * low_size;
+    char *tmp_buf = NULL;
+    opal_free_list_item_t *tmp_fl_item = NULL;
+    int tmp_fl_src = HAN_ALLOC_MALLOC;
+
     if (low_rank == root_low_rank) {
-        tmp_buf = (char *) malloc(block_size * low_size);
-
-        /* 1. up scatter (internode) between node leaders */
-        up_comm->c_coll->coll_scatter((char*) reorder_buf,
-                    count * low_size,
-                    dtype,
-                    (char *)tmp_buf,
-                    block_size * low_size,
-                    MPI_BYTE,
-                    root_up_rank,
-                    up_comm,
+        if (mca_coll_han_component.han_use_persist_buffers) {
+            tmp_buf = scatter_alloc_tiered(
+                &han_module->large_fragment_freelist,
+                mca_coll_han_component.han_large_fragment_size,
+                &han_module->fragment_freelist,
+                mca_coll_han_component.han_fragment_size,
+                tmp_total, &tmp_fl_item, &tmp_fl_src);
+            /* If tiered alloc fell back to malloc (src==0), use persist instead */
+            if (tmp_fl_src == HAN_ALLOC_MALLOC && tmp_buf != NULL) {
+                free(tmp_buf);
+                tmp_buf = NULL;
+            }
+            if (tmp_fl_src == HAN_ALLOC_MALLOC) {
+                tmp_buf = han_scratch_alloc(&han_module->scratch_buf[1],
+                                                &han_module->scratch_buf_size[1],
+                                                tmp_total);
+                if (NULL == tmp_buf) return OMPI_ERR_OUT_OF_RESOURCE;
+            }
+        } else {
+            tmp_buf = (char *)malloc(tmp_total);
+            if (NULL == tmp_buf) return OMPI_ERR_OUT_OF_RESOURCE;
+        }
+
+        up_comm->c_coll->coll_scatter((char *)reorder_buf,
+                    count * low_size, dtype,
+                    tmp_buf,
+                    block_size * low_size, MPI_BYTE,
+                    root_up_rank, up_comm,
                     up_comm->c_coll->coll_scatter_module);
     }
 
-    /* 2. low scatter on nodes leaders */
-    low_comm->c_coll->coll_scatter((char *)tmp_buf,
-                     block_size,
-                     MPI_BYTE,
-                     (char*)rbuf,
-                     rcount,
-                     rdtype,
-                     root_low_rank,
-                     low_comm,
+    low_comm->c_coll->coll_scatter(tmp_buf,
+                     block_size, MPI_BYTE,
+                     (char *)rbuf, rcount, rdtype,
+                     root_low_rank, low_comm,
                      low_comm->c_coll->coll_scatter_module);
 
     if (low_rank == root_low_rank) {
-        free(tmp_buf);
-        tmp_buf = NULL;
+        if (mca_coll_han_component.han_use_persist_buffers) {
+            if (tmp_fl_src != HAN_ALLOC_MALLOC) {
+                scatter_free_tiered(&han_module->large_fragment_freelist,
+                                    &han_module->fragment_freelist,
+                                    tmp_fl_item, tmp_buf, tmp_fl_src);
+            }
+            /* persist buffer (src==0) is not freed */
+        } else {
+            free(tmp_buf);
+        }
     }
-    if (reorder_buf != sbuf) {
+
+    if (!mca_coll_han_component.han_use_persist_buffers && !reorder_is_sbuf) {
         free(reorder_buf);
     }
 
     return OMPI_SUCCESS;
-
 }
diff --git a/ompi/mca/coll/han/coll_han_scatterv.c b/ompi/mca/coll/han/coll_han_scatterv.c
index 18c67baff91..dfc23175ff5 100644
--- a/ompi/mca/coll/han/coll_han_scatterv.c
+++ b/ompi/mca/coll/han/coll_han_scatterv.c
@@ -226,7 +226,10 @@ int mca_coll_han_scatterv_intra(const void *sbuf, ompi_count_array_t scounts, om
         if (need_bounce_buf) {
             ptrdiff_t ssize, sgap;
             ssize = opal_datatype_span(&rdtype->super, total_up_scounts, &sgap);
-            bounce_buf = malloc(ssize);
+            bounce_buf = han_scratch_or_malloc(
+                &han_module->scratch_buf[0],
+                &han_module->scratch_buf_size[0],
+                ssize, mca_coll_han_component.han_use_persist_buffers);
             if (!bounce_buf) {
                 err = OMPI_ERR_OUT_OF_RESOURCE;
                 goto root_out;
@@ -293,7 +296,7 @@ int mca_coll_han_scatterv_intra(const void *sbuf, ompi_count_array_t scounts, om
         if (up_peer_ub) {
             free(up_peer_ub);
         }
-        if (bounce_buf) {
+        if (bounce_buf && !mca_coll_han_component.han_use_persist_buffers) {
             free(bounce_buf);
         }
 
@@ -355,7 +358,10 @@ int mca_coll_han_scatterv_intra(const void *sbuf, ompi_count_array_t scounts, om
         total_rsize += low_scounts[i];
     }
 
-    tmp_buf = (char *) malloc(total_rsize); /* tmp_buf is still valid if total_rsize is 0 */
+    tmp_buf = han_scratch_or_malloc(
+        &han_module->scratch_buf[1],
+        &han_module->scratch_buf_size[1],
+        total_rsize, mca_coll_han_component.han_use_persist_buffers);
     if (!tmp_buf) {
         err = OMPI_ERR_OUT_OF_RESOURCE;
         goto node_leader_out;
@@ -382,7 +388,7 @@ int mca_coll_han_scatterv_intra(const void *sbuf, ompi_count_array_t scounts, om
     if (low_displs) {
         free(low_displs);
     }
-    if (tmp_buf) {
+    if (tmp_buf && !mca_coll_han_component.han_use_persist_buffers) {
         free(tmp_buf);
     }
 
diff --git a/ompi/mca/coll/han/coll_han_subcomms.c b/ompi/mca/coll/han/coll_han_subcomms.c
index 9fcd65dad9b..ccee0392238 100644
--- a/ompi/mca/coll/han/coll_han_subcomms.c
+++ b/ompi/mca/coll/han/coll_han_subcomms.c
@@ -7,7 +7,8 @@
  *                         Laboratory, ICS Forth. All rights reserved.
  * Copyright (c) 2024      Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
- * Copyright (c) 2024      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2024-2026 NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University. All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -46,15 +47,6 @@
         (COMM)->c_coll->coll_##COLL##_module = (FALLBACKS).COLL.module;      \
     } while (0)
 
-#define HAN_SUBCOM_EXTRA_RETAIN(COMM, PARENT_COMM)                           \
-    do                                                                       \
-    {                                                                        \
-        if (OMPI_COMM_CID_IS_LOWER(COMM, PARENT_COMM)) {                     \
-            OMPI_COMM_SET_EXTRA_RETAIN(COMM);                                \
-            OBJ_RETAIN(COMM);                                                \
-        }                                                                    \
-    } while (0)
-
 /*
  * Routine that creates the local hierarchical sub-communicators
  * Called each time a collective is called.
@@ -215,10 +207,10 @@ int mca_coll_han_comm_create_new(struct ompi_communicator_t *comm,
     HAN_SUBCOM_RESTORE_COLLECTIVE(fallbacks, comm, han_module, scatterv);
 
     OBJ_DESTRUCT(&comm_info);
-   
-    /* Ensure these communicators aren't released before the parent comm */
-    HAN_SUBCOM_EXTRA_RETAIN(*low_comm, comm);
-    HAN_SUBCOM_EXTRA_RETAIN(*up_comm, comm);
+
+    /* Retain sub-communicators so they survive finalize ordering */
+    OBJ_RETAIN(*low_comm);
+    OBJ_RETAIN(*up_comm);
 
     return OMPI_SUCCESS;
 
@@ -245,9 +237,9 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
 {
     int low_rank, low_size, up_rank, w_rank, w_size;
     mca_coll_han_collectives_fallback_t fallbacks;
-    ompi_communicator_t **low_comms;
-    ompi_communicator_t **up_comms;
+    ompi_communicator_t **low_comms = NULL, **up_comms = NULL;
     int vrank, *vranks;
+    int rc;
     opal_info_t comm_info;
 
     /* use cached communicators if possible */
@@ -257,6 +249,8 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
         return OMPI_SUCCESS;
     }
 
+    OBJ_CONSTRUCT(&comm_info, opal_info_t);
+
     /*
      * We cannot use han allreduce and allgather without sub-communicators,
      * but we are in the creation of the data structures for the HAN, and
@@ -290,10 +284,14 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
      * all participants.
      */
     int local_procs = ompi_group_count_local_peers(comm->c_local_group);
-    comm->c_coll->coll_allreduce(MPI_IN_PLACE, &local_procs, 1, MPI_INT,
-                                 MPI_MAX, comm,
-                                 comm->c_coll->coll_allreduce_module);
+    rc = comm->c_coll->coll_allreduce(MPI_IN_PLACE, &local_procs, 1, MPI_INT,
+                                      MPI_MAX, comm,
+                                      comm->c_coll->coll_allreduce_module);
+    if (OMPI_SUCCESS != rc) {
+        goto final_agree;
+    }
     if( local_procs == 1 ) {
+        OBJ_DESTRUCT(&comm_info);
         /* restore saved collectives */
         HAN_SUBCOM_RESTORE_COLLECTIVE(fallbacks, comm, han_module, alltoall);
         HAN_SUBCOM_RESTORE_COLLECTIVE(fallbacks, comm, han_module, alltoallv);
@@ -313,20 +311,21 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
     /* create communicators if there is no cached communicator */
     w_rank = ompi_comm_rank(comm);
     w_size = ompi_comm_size(comm);
-    low_comms = (struct ompi_communicator_t **)malloc(COLL_HAN_LOW_MODULES *
+    low_comms = (struct ompi_communicator_t **)calloc(COLL_HAN_LOW_MODULES,
                                                       sizeof(struct ompi_communicator_t *));
-    up_comms = (struct ompi_communicator_t **)malloc(COLL_HAN_UP_MODULES *
+    up_comms = (struct ompi_communicator_t **)calloc(COLL_HAN_UP_MODULES,
                                                      sizeof(struct ompi_communicator_t *));
 
-    OBJ_CONSTRUCT(&comm_info, opal_info_t);
-
     /*
      * Upgrade sm module priority to set up low_comms[0] with sm module
      * This sub-communicator contains the ranks that share my node.
      */
     opal_info_set(&comm_info, "ompi_comm_coll_preference", "tuned,^han");
-    ompi_comm_split_type(comm, MPI_COMM_TYPE_SHARED, 0,
-                         &comm_info, &(low_comms[0]));
+    rc = ompi_comm_split_type(comm, MPI_COMM_TYPE_SHARED, 0,
+                              &comm_info, &(low_comms[0]));
+    if (OMPI_SUCCESS != rc) {
+        goto final_agree;
+    }
     assert(OMPI_COMM_IS_DISJOINT_SET(low_comms[0]) && !OMPI_COMM_IS_DISJOINT(low_comms[0]));
 
     /*
@@ -340,21 +339,30 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
      * This sub-communicator contains the ranks that share my node.
      */
     opal_info_set(&comm_info, "ompi_comm_coll_preference", "sm,^han");
-    ompi_comm_split_type(comm, MPI_COMM_TYPE_SHARED, 0,
+    rc = ompi_comm_split_type(comm, MPI_COMM_TYPE_SHARED, 0,
                          &comm_info, &(low_comms[1]));
+    if (OMPI_SUCCESS != rc) {
+        goto final_agree;
+    }
     assert(OMPI_COMM_IS_DISJOINT_SET(low_comms[1]) && !OMPI_COMM_IS_DISJOINT(low_comms[1]));
 
     opal_info_set(&comm_info, "ompi_comm_coll_preference", "xhc,^han");
-    ompi_comm_split_type(comm, MPI_COMM_TYPE_SHARED, 0,
+    rc = ompi_comm_split_type(comm, MPI_COMM_TYPE_SHARED, 0,
                          &comm_info, &(low_comms[2]));
-
+    if (OMPI_SUCCESS != rc) {
+        goto final_agree;
+    }
+    assert(OMPI_COMM_IS_DISJOINT_SET(low_comms[2]) && !OMPI_COMM_IS_DISJOINT(low_comms[2]));
     /*
      * Upgrade libnbc module priority to set up up_comms[0] with libnbc module
      * This sub-communicator contains one process per node: processes with the
      * same intra-node rank id share such a sub-communicator
      */
     opal_info_set(&comm_info, "ompi_comm_coll_preference", "libnbc,^han");
-    ompi_comm_split_with_info(comm, low_rank, w_rank, &comm_info, &(up_comms[0]), false);
+    rc = ompi_comm_split_with_info(comm, low_rank, w_rank, &comm_info, &(up_comms[0]), false);
+    if (OMPI_SUCCESS != rc) {
+        goto final_agree;
+    }
     up_rank = ompi_comm_rank(up_comms[0]);
     assert(OMPI_COMM_IS_DISJOINT_SET(up_comms[0]) && OMPI_COMM_IS_DISJOINT(up_comms[0]));
 
@@ -363,7 +371,10 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
      * This sub-communicator contains one process per node.
      */
     opal_info_set(&comm_info, "ompi_comm_coll_preference", "adapt,^han");
-    ompi_comm_split_with_info(comm, low_rank, w_rank, &comm_info, &(up_comms[1]), false);
+    rc = ompi_comm_split_with_info(comm, low_rank, w_rank, &comm_info, &(up_comms[1]), false);
+    if (OMPI_SUCCESS != rc) {
+        goto final_agree;
+    }
     assert(OMPI_COMM_IS_DISJOINT_SET(up_comms[1]) && OMPI_COMM_IS_DISJOINT(up_comms[1]));
 
     /*
@@ -380,9 +391,11 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
      * gather vrank from each process so every process will know other processes
      * vrank
      */
-    comm->c_coll->coll_allgather(&vrank, 1, MPI_INT, vranks, 1, MPI_INT, comm,
+    rc = comm->c_coll->coll_allgather(&vrank, 1, MPI_INT, vranks, 1, MPI_INT, comm,
                                  comm->c_coll->coll_allgather_module);
-
+    if (OMPI_SUCCESS != rc) {
+        goto final_agree;
+    }
     /*
      * Set the cached info
      */
@@ -390,12 +403,66 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
     han_module->cached_up_comms = up_comms;
     han_module->cached_vranks = vranks;
 
-    /* Ensure these communicators aren't released before the parent comm */
+    /* Retain sub-communicators so they survive finalize ordering */
     for(int i = 0; i < COLL_HAN_LOW_MODULES; i++) {
-        HAN_SUBCOM_EXTRA_RETAIN(low_comms[i], comm);
+        OBJ_RETAIN(low_comms[i]);
     }
     for(int i = 0; i < COLL_HAN_UP_MODULES; i++) {
-        HAN_SUBCOM_EXTRA_RETAIN(up_comms[i], comm);
+        OBJ_RETAIN(up_comms[i]);
+    }
+
+
+final_agree:
+
+    OBJ_DESTRUCT(&comm_info);
+
+    if (OMPI_SUCCESS != rc) {
+        /**
+         * Revoke the input communicator to ensure no process is stuck.
+         */
+        ompi_comm_revoke_internal(comm);
+    }
+
+    /**
+     * Agree that everyone has successfully created the sub-communicators.
+     */
+
+    int agree_flag = (OMPI_SUCCESS == rc) ? 1 : 0;
+    ompi_group_t *failed_group = &ompi_mpi_group_empty.group;
+    int agree_rc = comm->c_coll->coll_agree( &agree_flag,
+                                    1,
+                                    &ompi_mpi_int.dt,
+                                    &ompi_mpi_op_band.op,
+                                    &failed_group, false,
+                                    comm,
+                                    comm->c_coll->coll_agree_module);
+
+    if (OMPI_SUCCESS != agree_rc) {
+        agree_flag = 0;  /* agree failed so make sure to tear everything down */
+        rc = agree_rc;
+    }
+
+    if (!agree_flag) {
+        han_module->enabled = false;  /* entire module set to pass-through from now on */
+        if (low_comms != NULL) {
+            for(int i = 0; i < COLL_HAN_LOW_MODULES; i++) {
+                if (NULL != low_comms[i]) {
+                    ompi_comm_revoke_internal(low_comms[i]);
+                    ompi_comm_free(&low_comms[i]);
+                }
+            }
+            free(low_comms);
+        }
+        if (up_comms != NULL) {
+            for(int i = 0; i < COLL_HAN_UP_MODULES; i++) {
+                if (NULL != up_comms[i]) {
+                    ompi_comm_revoke_internal(up_comms[i]);
+                    ompi_comm_free(&up_comms[i]);
+                }
+            }
+            free(up_comms);
+        }
+        return rc;  /* sub-communicator creation failed on at least one process */
     }
 
     /* Reset the saved collectives to point back to HAN */
@@ -411,7 +478,6 @@ int mca_coll_han_comm_create(struct ompi_communicator_t *comm,
     HAN_SUBCOM_RESTORE_COLLECTIVE(fallbacks, comm, han_module, scatter);
     HAN_SUBCOM_RESTORE_COLLECTIVE(fallbacks, comm, han_module, scatterv);
 
-    OBJ_DESTRUCT(&comm_info);
     return OMPI_SUCCESS;
 }
 
diff --git a/ompi/mca/coll/inter/coll_inter_allgatherv.c b/ompi/mca/coll/inter/coll_inter_allgatherv.c
index fa7c9e14301..a0c7881bcff 100644
--- a/ompi/mca/coll/inter/coll_inter_allgatherv.c
+++ b/ompi/mca/coll/inter/coll_inter_allgatherv.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2015-2017 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2022      IBM Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -107,21 +108,8 @@ mca_coll_inter_allgatherv_inter(const void *sbuf, size_t scount,
         goto exit;
     }
 
-    /* TODO:BIGCOUNT: Remove tehese temporaries once ompi_datatype is updated for bigcount */
-    int *tmp_rcounts = malloc(sizeof(int) * size);
-    int *tmp_disps = malloc(sizeof(int) * size);
-    if (NULL == tmp_rcounts || NULL == tmp_disps) {
-        err = OMPI_ERR_OUT_OF_RESOURCE;
-        goto exit;
-    }
-    for (i = 0; i < size; ++i) {
-        tmp_rcounts[i] = (int) ompi_count_array_get(rcounts, i);
-        tmp_disps[i] = (int) ompi_disp_array_get(disps, i);
-    }
-    ompi_datatype_create_indexed(size,tmp_rcounts,tmp_disps,rdtype,&ndtype);
+    ompi_datatype_create_indexed(size,rcounts,disps,rdtype,&ndtype);
     ompi_datatype_commit(&ndtype);
-    free(tmp_rcounts);
-    free(tmp_disps);
 
     if (0 == rank) {
 	/* Exchange data between roots */
diff --git a/ompi/mca/coll/inter/coll_inter_gatherv.c b/ompi/mca/coll/inter/coll_inter_gatherv.c
index 1e1d8840a44..73d3716ca8e 100644
--- a/ompi/mca/coll/inter/coll_inter_gatherv.c
+++ b/ompi/mca/coll/inter/coll_inter_gatherv.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2015-2016 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2022      IBM Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -62,20 +63,8 @@ mca_coll_inter_gatherv_inter(const void *sbuf, size_t scount,
     size_local = ompi_comm_size(comm);
 
     if (MPI_ROOT == root) { /* I am the root, receiving the data from zero. */
-        /* TODO:BIGCOUNT: Remove these temporaries once ompi_datatype is updated for bigcount */
-        int *tmp_rcounts = malloc(sizeof(int) * size);
-        int *tmp_disps = malloc(sizeof(int) * size);
-        if (NULL == tmp_rcounts || NULL == tmp_disps) {
-            return OMPI_ERR_OUT_OF_RESOURCE;
-        }
-        for (i = 0; i < size; ++i) {
-            tmp_rcounts[i] = ompi_count_array_get(rcounts, i);
-            tmp_disps[i] = ompi_disp_array_get(disps, i);
-        }
-        ompi_datatype_create_indexed(size, tmp_rcounts, tmp_disps, rdtype, &ndtype);
+        ompi_datatype_create_indexed(size, rcounts, disps, rdtype, &ndtype);
         ompi_datatype_commit(&ndtype);
-        free(tmp_rcounts);
-        free(tmp_disps);
 
         err = MCA_PML_CALL(recv(rbuf, 1, ndtype, 0,
                                 MCA_COLL_BASE_TAG_GATHERV,
diff --git a/ompi/mca/coll/inter/coll_inter_scatterv.c b/ompi/mca/coll/inter/coll_inter_scatterv.c
index 5d98e1ea099..9f97af68a45 100644
--- a/ompi/mca/coll/inter/coll_inter_scatterv.c
+++ b/ompi/mca/coll/inter/coll_inter_scatterv.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2015-2016 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2022      IBM Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -100,9 +101,9 @@ mca_coll_inter_scatterv_inter(const void *sbuf, ompi_count_array_t scounts,
 		displace[i] = displace[i-1] + counts[i-1];
 	    }
 	}
-	/* perform the scatterv locally */
 	OMPI_COUNT_ARRAY_INIT(&counts_arg, counts);
 	OMPI_DISP_ARRAY_INIT(&displace_arg, displace);
+	/* perform the scatterv locally */
 	err = comm->c_local_comm->c_coll->coll_scatterv(ptmp, counts_arg, displace_arg,
 						       rdtype, rbuf, rcount,
 						       rdtype, 0, comm->c_local_comm,
@@ -139,20 +140,8 @@ mca_coll_inter_scatterv_inter(const void *sbuf, ompi_count_array_t scounts,
 	    return err;
 	}
 
-	/* TODO:BIGCOUNT: Remove these temporaries once ompi_datatype is updated for bigcount */
-	int *tmp_scounts = malloc(sizeof(int) * size);
-	int *tmp_disps = malloc(sizeof(int) * size);
-	if (NULL == tmp_scounts || NULL == tmp_disps) {
-	    return OMPI_ERR_OUT_OF_RESOURCE;
-	}
-	for (i = 0; i < size; ++i) {
-	    tmp_scounts[i] = (int) ompi_count_array_get(scounts, i);
-	    tmp_disps[i] = (int) ompi_disp_array_get(disps, i);
-	}
-	ompi_datatype_create_indexed(size,tmp_scounts,tmp_disps,sdtype,&ndtype);
+	ompi_datatype_create_indexed(size,scounts,disps,sdtype,&ndtype);
 	ompi_datatype_commit(&ndtype);
-	free(tmp_scounts);
-	free(tmp_disps);
 
 	err = MCA_PML_CALL(send(sbuf, 1, ndtype, 0,
 				MCA_COLL_BASE_TAG_SCATTERV,
diff --git a/ompi/mca/coll/tuned/coll_tuned.h b/ompi/mca/coll/tuned/coll_tuned.h
index 47634caec25..53bb8705aa0 100644
--- a/ompi/mca/coll/tuned/coll_tuned.h
+++ b/ompi/mca/coll/tuned/coll_tuned.h
@@ -113,6 +113,7 @@ int ompi_coll_tuned_allgatherv_intra_check_forced_init(coll_tuned_force_algorith
 
 /* All Reduce */
 int ompi_coll_tuned_allreduce_intra_dec_fixed(ALLREDUCE_ARGS);
+int ompi_coll_tuned_allreduce_intra_disjoint_dec_fixed(ALLREDUCE_ARGS);
 int ompi_coll_tuned_allreduce_intra_dec_dynamic(ALLREDUCE_ARGS);
 int ompi_coll_tuned_allreduce_intra_do_this(ALLREDUCE_ARGS, int algorithm, int faninout, int segsize);
 int ompi_coll_tuned_allreduce_intra_check_forced_init (coll_tuned_force_algorithm_mca_param_indices_t *mca_param_indices);
diff --git a/ompi/mca/coll/tuned/coll_tuned_decision_fixed.c b/ompi/mca/coll/tuned/coll_tuned_decision_fixed.c
index e97993ffe10..3b0077c9bcc 100644
--- a/ompi/mca/coll/tuned/coll_tuned_decision_fixed.c
+++ b/ompi/mca/coll/tuned/coll_tuned_decision_fixed.c
@@ -218,6 +218,194 @@ ompi_coll_tuned_allreduce_intra_dec_fixed(const void *sbuf, void *rbuf, size_t c
                                                     comm, module, alg, 0, 0);
 }
 
+
+/*
+ *  allreduce_intra_disjoint
+ *
+ *  Function:   - selects allreduce algorithm to use for disjoint (inter-node)
+ *                communicators, whose communication patterns differ from intra-node.
+ *                This function implements a decision tree that selects the most
+ *                efficient allreduce algorithm based on communicator size, message
+ *                size, and operation commutativity.
+ *  Accepts:    - same as MPI_Allreduce()
+ *  Returns:    - MPI_SUCCESS or error code
+ */
+int
+ompi_coll_tuned_allreduce_intra_disjoint_dec_fixed(const void *sbuf, void *rbuf, size_t count,
+                                                   struct ompi_datatype_t *dtype,
+                                                   struct ompi_op_t *op,
+                                                   struct ompi_communicator_t *comm,
+                                                   mca_coll_base_module_t *module)
+{
+
+    size_t dsize, total_dsize;
+    int communicator_size, alg;
+    communicator_size = ompi_comm_size(comm);
+    OPAL_OUTPUT_VERBOSE((COLL_TUNED_TRACING_VERBOSE, ompi_coll_tuned_stream,
+        "ompi_coll_tuned_allreduce_intra_disjoint_dec_fixed"));
+
+    ompi_datatype_type_size(dtype, &dsize);
+    total_dsize = dsize * (ptrdiff_t)count;
+
+    /** Algorithms:
+     *  {1, "basic_linear"},
+     *  {2, "nonoverlapping"},
+     *  {3, "recursive_doubling"},
+     *  {4, "ring"},
+     *  {5, "segmented_ring"},
+     *  {6, "rabenseifner"},
+     *  {7, "allgather_reduce"}
+     *
+     * Currently, ring, segmented ring, and rabenseifner do not support
+     * non-commutative operations.
+     */
+    if( !ompi_op_is_commute(op) ) {
+        if (communicator_size == 2) {
+            alg = 3;
+        } else if (communicator_size < 4) {
+            alg = 7;
+        } else if (communicator_size < 8) {
+            if (total_dsize < 1048576) {
+                alg = 7;
+            } else {
+                alg = 3;
+            }
+        } else if (communicator_size < 16) {
+            if (total_dsize < 262144) {
+                alg = 7;
+            } else {
+                alg = 3;
+            }
+        } else if (communicator_size < 32) {
+            if (total_dsize < 32768) {
+                alg = 7;
+            } else if (total_dsize < 131072) {
+                alg = 2;
+            } else {
+                alg = 3;
+            }
+        } else if (communicator_size <= 64) {
+            if (total_dsize < 32768) {
+                alg = 7;
+            } else {
+                alg = 3;
+            }
+        } else if (communicator_size < 128) {
+            alg = 3;
+        } else if (communicator_size < 256) {
+            if (total_dsize < 131072) {
+                alg = 2;
+            } else if (total_dsize < 524288) {
+                alg = 3;
+            } else {
+                alg = 2;
+            }
+        } else if (communicator_size < 512) {
+            if (total_dsize < 4096) {
+                alg = 2;
+            } else if (total_dsize < 524288) {
+                alg = 3;
+            } else {
+                alg = 2;
+            }
+        } else {
+            if (total_dsize < 2048) {
+                alg = 2;
+            } else {
+                alg = 3;
+            }
+        }
+    } else {
+        if (communicator_size == 2) {
+            alg = 3;
+        } else if (communicator_size < 4) {
+            alg = 7;
+        } else if (communicator_size < 8) {
+            if (total_dsize < 1048576) {
+                alg = 7;
+            } else {
+                alg = 3;
+            }
+        } else if (communicator_size < 16) {
+            if (total_dsize < 262144) {
+                alg = 7;
+            } else if (total_dsize < 1048576) {
+                alg = 6;
+            } else {
+                alg = 3;
+            }
+        } else if (communicator_size < 32) {
+            if (total_dsize < 32768) {
+                alg = 7;
+            } else if (total_dsize < 131072) {
+                alg = 2;
+            } else {
+                alg = 6;
+            }
+        } else if (communicator_size <= 64) {
+            if (total_dsize < 32768) {
+                alg = 7;
+            } else if (total_dsize < 131072) {
+                alg = 3;
+            } else {
+                alg = 6;
+            }
+        } else if (communicator_size < 128) {
+            if (total_dsize < 262144) {
+                alg = 3;
+            } else {
+                alg = 6;
+            }
+        } else if (communicator_size < 256) {
+            if (total_dsize < 131072) {
+                alg = 2;
+            } else if (total_dsize < 262144) {
+                alg = 3;
+            } else {
+                alg = 6;
+            }
+        } else if (communicator_size < 512) {
+            if (total_dsize < 4096) {
+                alg = 2;
+            } else {
+                alg = 6;
+            }
+        } else if (communicator_size < 2048) {
+            if (total_dsize < 2048) {
+                alg = 2;
+            } else if (total_dsize < 16384) {
+                alg = 3;
+            } else {
+                alg = 6;
+            }
+        } else if (communicator_size < 4096) {
+            if (total_dsize < 2048) {
+                alg = 2;
+            } else if (total_dsize < 4096) {
+                alg = 5;
+            } else if (total_dsize < 16384) {
+                alg = 3;
+            } else {
+                alg = 6;
+            }
+        } else {
+            if (total_dsize < 2048) {
+                alg = 2;
+            } else if (total_dsize < 16384) {
+                alg = 5;
+            } else if (total_dsize < 32768) {
+                alg = 3;
+            } else {
+                alg = 6;
+            }
+        }
+    }
+
+    return ompi_coll_tuned_allreduce_intra_do_this (sbuf, rbuf, count, dtype, op,
+                                                    comm, module, alg, 0, 0);
+}
+
+                           
 /*
  *	alltoall_intra_dec
  *
diff --git a/ompi/mca/coll/tuned/coll_tuned_module.c b/ompi/mca/coll/tuned/coll_tuned_module.c
index 20bb4c4a49b..f82bcf27951 100644
--- a/ompi/mca/coll/tuned/coll_tuned_module.c
+++ b/ompi/mca/coll/tuned/coll_tuned_module.c
@@ -105,12 +105,13 @@ ompi_coll_tuned_comm_query(struct ompi_communicator_t *comm, int *priority)
      */
     if (OMPI_COMM_IS_DISJOINT_SET(comm) && OMPI_COMM_IS_DISJOINT(comm)) {
         tuned_module->super.coll_bcast  = ompi_coll_tuned_bcast_intra_disjoint_dec_fixed;
+        tuned_module->super.coll_allreduce  = ompi_coll_tuned_allreduce_intra_disjoint_dec_fixed;
     } else {
         tuned_module->super.coll_bcast  = ompi_coll_tuned_bcast_intra_dec_fixed;
+        tuned_module->super.coll_allreduce  = ompi_coll_tuned_allreduce_intra_dec_fixed;
     }
     tuned_module->super.coll_allgather  = ompi_coll_tuned_allgather_intra_dec_fixed;
     tuned_module->super.coll_allgatherv = ompi_coll_tuned_allgatherv_intra_dec_fixed;
-    tuned_module->super.coll_allreduce  = ompi_coll_tuned_allreduce_intra_dec_fixed;
     tuned_module->super.coll_alltoall   = ompi_coll_tuned_alltoall_intra_dec_fixed;
     tuned_module->super.coll_alltoallv  = ompi_coll_tuned_alltoallv_intra_dec_fixed;
     tuned_module->super.coll_barrier    = ompi_coll_tuned_barrier_intra_dec_fixed;
diff --git a/ompi/mca/common/monitoring/monitoring_prof_f.c b/ompi/mca/common/monitoring/monitoring_prof_f.c
index 4e193a9b510..622ab3274a5 100644
--- a/ompi/mca/common/monitoring/monitoring_prof_f.c
+++ b/ompi/mca/common/monitoring/monitoring_prof_f.c
@@ -48,7 +48,7 @@ void monitoring_prof_mpi_finalize_f2c( MPI_Fint *ierr ) {
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
 }
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INIT = monitoring_prof_mpi_init_f2c
 #pragma weak mpi_init = monitoring_prof_mpi_init_f2c
 #pragma weak mpi_init_ = monitoring_prof_mpi_init_f2c
diff --git a/ompi/mca/common/ompio/common_ompio.h b/ompi/mca/common/ompio/common_ompio.h
index 8b12f7b8cc5..09e43cea071 100644
--- a/ompi/mca/common/ompio/common_ompio.h
+++ b/ompi/mca/common/ompio/common_ompio.h
@@ -17,6 +17,7 @@
  * Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -115,6 +116,14 @@ enum ompio_fs_type
     GPFS = 6
 };
 
+enum mca_common_ompio_info_phase_t
+{
+    MCA_COMMON_OMPIO_INFO_PHASE_OPEN,
+    MCA_COMMON_OMPIO_INFO_PHASE_SET_INFO,
+    MCA_COMMON_OMPIO_INFO_PHASE_SET_VIEW
+};
+typedef enum mca_common_ompio_info_phase_t mca_common_ompio_info_phase_t;
+
 typedef struct mca_common_ompio_io_array_t {
     void                 *memory_address;
     /* we need that of type OMPI_MPI_OFFSET_TYPE */
@@ -180,6 +189,7 @@ struct ompio_file_t {
     opal_convertor_t      *f_mem_convertor;
     opal_convertor_t      *f_file_convertor;
     opal_info_t           *f_info;
+    mca_common_ompio_info_phase_t f_info_phase;
     void                  *f_fs_ptr;
     int                    f_fs_block_size;
     int                    f_atomicity;
@@ -327,6 +337,18 @@ OMPI_DECLSPEC int mca_common_ompio_file_delete (const char *filename,
                                                 struct opal_info_t *info);
 OMPI_DECLSPEC int mca_common_ompio_create_incomplete_file_handle (const char *filename,
                                                                   ompio_file_t **fh);
+OMPI_DECLSPEC int mca_common_ompio_info_subscribe (ompio_file_t *fh,
+                                                   const char *key,
+                                                   const char *value,
+                                                   opal_key_interest_callback_t *callback);
+OMPI_DECLSPEC int mca_common_ompio_info_apply (ompio_file_t *fh,
+                                               opal_info_t *info);
+OMPI_DECLSPEC int mca_common_ompio_info_set (ompio_file_t *fh,
+                                             const char *key,
+                                             const char *value);
+OMPI_DECLSPEC int mca_common_ompio_info_dup (ompio_file_t *fh,
+                                             ompi_info_t **info_used);
+OMPI_DECLSPEC int mca_common_ompio_info_register (ompio_file_t *fh);
 
 OMPI_DECLSPEC int mca_common_ompio_file_close (ompio_file_t *ompio_fh);
 OMPI_DECLSPEC int mca_common_ompio_file_get_size (ompio_file_t *ompio_fh, OMPI_MPI_OFFSET_TYPE *size);
diff --git a/ompi/mca/common/ompio/common_ompio_file_open.c b/ompi/mca/common/ompio/common_ompio_file_open.c
index 9104b175e70..1b42546a12d 100644
--- a/ompi/mca/common/ompio/common_ompio_file_open.c
+++ b/ompi/mca/common/ompio/common_ompio_file_open.c
@@ -17,6 +17,8 @@
  * Copyright (c) 2018      DataDirect Networks. All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -39,6 +41,8 @@
 #include "ompi/mca/sharedfp/sharedfp.h"
 #include "ompi/mca/sharedfp/base/base.h"
 
+#include <stdio.h>
+#include <string.h>
 #include <unistd.h>
 #include <math.h>
 #include "common_ompio.h"
@@ -50,6 +54,238 @@
 static mca_common_ompio_generate_current_file_view_fn_t generate_current_file_view_fn;
 static mca_common_ompio_get_mca_parameter_value_fn_t get_mca_parameter_value_fn;
 
+/*
+ * The info subscriber callback both decides whether a key is public in
+ * MPI_File_get_info and updates the internal field that older OMPIO code
+ * reads.  Keeping that side effect here prevents a second parser from
+ * drifting away from the value returned to the application.
+ */
+static const char *mca_common_ompio_cb_buffer_size_cb (opal_infosubscriber_t *object,
+                                                      const char *key,
+                                                      const char *value)
+{
+    ompi_file_t *file;
+    mca_common_ompio_data_t *data;
+    ompio_file_t *fh;
+    int bytes_per_agg;
+
+    if (NULL == object || NULL == value) {
+        return NULL;
+    }
+
+    file = (ompi_file_t *) object;
+    data = (mca_common_ompio_data_t *) file->f_io_selected_data;
+    if (NULL == data) {
+        return NULL;
+    }
+    fh = &data->ompio_fh;
+
+    if (1 == sscanf(value, "%d", &bytes_per_agg)) {
+        fh->f_bytes_per_agg = bytes_per_agg;
+    }
+
+    OMPIO_MCA_PRINT_INFO(fh, key, value, "");
+    return value;
+}
+
+static const char *mca_common_ompio_keep_info_value_cb (opal_infosubscriber_t *object,
+                                                        const char *key,
+                                                        const char *value)
+{
+    if (NULL == object || NULL == key || NULL == value) {
+        return NULL;
+    }
+
+    return value;
+}
+
+static const char *mca_common_ompio_cb_nodes_cb (opal_infosubscriber_t *object,
+                                                 const char *key,
+                                                 const char *value)
+{
+    if (NULL == object || NULL == key || NULL == value) {
+        return NULL;
+    }
+
+    /*
+     * The num_aggregators MCA default is -1, which means "let OMPIO
+     * choose automatically."  That sentinel is useful internally but is
+     * not a meaningful MPI_Info value to report back to users.
+     */
+    if (0 == strcmp(value, "-1")) {
+        return NULL;
+    }
+
+    return value;
+}
+
+int mca_common_ompio_info_subscribe (ompio_file_t *fh,
+                                    const char *key,
+                                    const char *value,
+                                    opal_key_interest_callback_t *callback)
+{
+    int ret;
+
+    if (NULL == fh) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    /*
+     * Some nested OMPIO handles, such as private sharedfp handles, do not
+     * have a backing ompi_file_t.  They cannot participate in the public
+     * MPI_Info subscription mechanism, and treating registration as a
+     * no-op keeps those internal opens on the old behavior path.
+     */
+    if (NULL == fh->f_fh) {
+        return OMPI_SUCCESS;
+    }
+
+    if (NULL == key || NULL == callback) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    ret = opal_infosubscribe_subscribe(&fh->f_fh->super, key, value, callback);
+    if (OPAL_SUCCESS == ret) {
+        /*
+         * f_info is intentionally borrowed.  The actual storage belongs to
+         * ompi_file_t::super.s_info so MPI_File_get_info and
+         * MPI_File_set_info see the same object as the lower OMPIO code.
+         */
+        fh->f_info = fh->f_fh->super.s_info;
+    }
+
+    return ret;
+}
+
+int mca_common_ompio_info_apply (ompio_file_t *fh,
+                                opal_info_t *info)
+{
+    int ret;
+
+    if (NULL == fh || NULL == fh->f_fh) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    ret = opal_infosubscribe_change_info(&fh->f_fh->super, info);
+    if (OPAL_SUCCESS == ret) {
+        fh->f_info = fh->f_fh->super.s_info;
+    }
+
+    return ret;
+}
+
+int mca_common_ompio_info_set (ompio_file_t *fh,
+                              const char *key,
+                              const char *value)
+{
+    if (NULL == fh || NULL == key || NULL == value) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    /*
+     * Internal nested OMPIO handles do not have a backing ompi_file_t and
+     * therefore cannot publish user-visible MPI_Info values.  Treat this
+     * like info_subscribe(): a successful no-op instead of writing into the
+     * borrowed info object passed to the internal open path.
+     */
+    if (NULL == fh->f_fh) {
+        return OMPI_SUCCESS;
+    }
+
+    if (NULL == fh->f_info) {
+        if (NULL == fh->f_fh->super.s_info) {
+            return OMPI_ERR_BAD_PARAM;
+        }
+        fh->f_info = fh->f_fh->super.s_info;
+    }
+
+    return opal_info_set(fh->f_info, key, value);
+}
+
+int mca_common_ompio_info_dup (ompio_file_t *fh,
+                              ompi_info_t **info_used)
+{
+    int ret;
+    opal_info_t *opal_info_used;
+
+    if (NULL == fh || NULL == info_used) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    *info_used = ompi_info_allocate();
+    if (NULL == *info_used) {
+        return OMPI_ERR_OUT_OF_RESOURCE;
+    }
+
+    if (NULL == fh->f_info) {
+        if (NULL == fh->f_fh || NULL == fh->f_fh->super.s_info) {
+            ompi_info_free(info_used);
+            return OMPI_ERR_BAD_PARAM;
+        }
+        fh->f_info = fh->f_fh->super.s_info;
+    }
+
+    /*
+     * MPI requires MPI_File_get_info to return a new caller-owned
+     * MPI_Info handle.  Duplicate only public entries; rejected user hints
+     * remain internal in s_info so components can ignore them without
+     * exposing them as accepted hints.
+     */
+    opal_info_used = &(*info_used)->super;
+    ret = opal_info_dup_public(fh->f_info, &opal_info_used);
+    if (OPAL_SUCCESS != ret) {
+        ompi_info_free(info_used);
+        return ret;
+    }
+
+    return OMPI_SUCCESS;
+}
+
+int mca_common_ompio_info_register (ompio_file_t *fh)
+{
+    char default_value[32];
+    int num_aggregators;
+    int ret;
+    int size;
+
+    if (NULL == fh) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    if (NULL == fh->f_fh) {
+        return OMPI_SUCCESS;
+    }
+
+    size = snprintf(default_value, sizeof(default_value), "%d", fh->f_bytes_per_agg);
+    if (0 > size || sizeof(default_value) <= (size_t) size) {
+        return OMPI_ERR_VALUE_OUT_OF_BOUNDS;
+    }
+
+    ret = mca_common_ompio_info_subscribe (fh, "cb_buffer_size",
+                                           default_value,
+                                           mca_common_ompio_cb_buffer_size_cb);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    num_aggregators = OMPIO_MCA_GET(fh, num_aggregators);
+    size = snprintf(default_value, sizeof(default_value), "%d", num_aggregators);
+    if (0 > size || sizeof(default_value) <= (size_t) size) {
+        return OMPI_ERR_VALUE_OUT_OF_BOUNDS;
+    }
+
+    ret = mca_common_ompio_info_subscribe (fh, "cb_nodes",
+                                           default_value,
+                                           mca_common_ompio_cb_nodes_cb);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    return mca_common_ompio_info_subscribe (fh, "collective_buffering",
+                                            "true",
+                                            mca_common_ompio_keep_info_value_cb);
+}
+
 int mca_common_ompio_file_open (ompi_communicator_t *comm,
                                 const char *filename,
                                 int amode,
@@ -99,6 +335,7 @@ int mca_common_ompio_file_open (ompi_communicator_t *comm,
     ompio_fh->f_fstype = NONE;
     ompio_fh->f_amode  = amode;
     ompio_fh->f_info   = info;
+    ompio_fh->f_info_phase = MCA_COMMON_OMPIO_INFO_PHASE_OPEN;
 
     /* set some function pointers required for fcoll, fbtls and sharedfp modules*/
     ompio_fh->f_generate_current_file_view = generate_current_file_view_fn;
@@ -122,6 +359,10 @@ int mca_common_ompio_file_open (ompi_communicator_t *comm,
     }
     
     mca_common_ompio_set_file_defaults (ompio_fh);
+    ret = mca_common_ompio_info_register (ompio_fh);
+    if (OMPI_SUCCESS != ret) {
+        goto fn_fail;
+    }
 
     ompio_fh->f_split_coll_req    = NULL;
     ompio_fh->f_split_coll_in_use = false;
@@ -441,24 +682,16 @@ int mca_common_ompio_set_file_defaults (ompio_file_t *fh)
 {
 
    if (NULL != fh) {
-       opal_cstring_t *stripe_str;
        ompi_datatype_t *types[2];
        int blocklen[2] = {1, 1};
        ptrdiff_t d[2], base;
-       int i, flag;
+       int i;
        
        fh->f_flags         = 0;
        fh->f_perm          = OMPIO_PERM_NULL;
        fh->f_io_array      = NULL;
        
        fh->f_bytes_per_agg = OMPIO_MCA_GET(fh, bytes_per_agg);
-       opal_info_get (fh->f_info, "cb_buffer_size", &stripe_str, &flag);
-       if ( flag ) {
-           /* Info object trumps mca parameter value */
-           sscanf ( stripe_str->string, "%d", &fh->f_bytes_per_agg  );
-           OMPIO_MCA_PRINT_INFO(fh, "cb_buffer_size", stripe_str->string, "");
-           OBJ_RELEASE(stripe_str);
-       }
 
        fh->f_fs_block_size = 4096;
        fh->f_atomicity     = 0;
@@ -502,8 +735,8 @@ int mca_common_ompio_set_file_defaults (ompio_file_t *fh)
        }
        
        ompi_datatype_create_struct (2,
-                                    blocklen,
-                                    d,
+                                    OMPI_COUNT_ARRAY_CREATE(blocklen),
+                                    OMPI_DISP_ARRAY_CREATE(d),
                                     types,
                                     &fh->f_iov_type);
        ompi_datatype_commit (&fh->f_iov_type);
diff --git a/ompi/mca/common/ompio/common_ompio_file_read_all.c b/ompi/mca/common/ompio/common_ompio_file_read_all.c
index 1b2f8d6c474..862da9ebeb5 100644
--- a/ompi/mca/common/ompio/common_ompio_file_read_all.c
+++ b/ompi/mca/common/ompio/common_ompio_file_read_all.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2024      Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -502,6 +503,9 @@ mca_common_ompio_base_file_read_all (struct ompio_file_t *fh,
          *****************************************************************/
         bytes_received = 0;
 
+        /**
+         * TODO: replace with big count?
+         */
         while (bytes_to_read_in_cycle) {
             /* This next block identifies which process is the holder
             ** of the sorted[current_index] element;
@@ -774,8 +778,8 @@ mca_common_ompio_base_file_read_all (struct ompio_file_t *fh,
                 send_req[i] = MPI_REQUEST_NULL;
                 if ( 0 < disp_index[i] ) {
                     ompi_datatype_create_hindexed(disp_index[i],
-                                                  blocklen_per_process[i],
-                                                  displs_per_process[i],
+                                                  OMPI_COUNT_ARRAY_CREATE(blocklen_per_process[i]),
+                                                  OMPI_DISP_ARRAY_CREATE(displs_per_process[i]),
                                                   MPI_BYTE,
                                                   &sendtype[i]);
                     ompi_datatype_commit(&sendtype[i]);
@@ -854,8 +858,8 @@ mca_common_ompio_base_file_read_all (struct ompio_file_t *fh,
             }
 
             ompi_datatype_create_hindexed(block_index+1,
-                                          blocklength_proc,
-                                          displs_proc,
+                                          OMPI_COUNT_ARRAY_CREATE(blocklength_proc),
+                                          OMPI_DISP_ARRAY_CREATE(displs_proc),
                                           MPI_BYTE,
                                           &newType);
             ompi_datatype_commit(&newType);
diff --git a/ompi/mca/common/ompio/common_ompio_file_view.c b/ompi/mca/common/ompio/common_ompio_file_view.c
index 8ea15de14d6..1d5dd557e72 100644
--- a/ompi/mca/common/ompio/common_ompio_file_view.c
+++ b/ompi/mca/common/ompio/common_ompio_file_view.c
@@ -14,6 +14,8 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2017      IBM Corporation. All rights reserved.
  * Copyright (c) 2023      Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -34,6 +36,27 @@
 
 static OMPI_MPI_OFFSET_TYPE get_contiguous_chunk_size (ompio_file_t *, int flag);
 static int datatype_duplicate (ompi_datatype_t *oldtype, ompi_datatype_t **newtype );
+static int get_current_info_value (ompio_file_t *fh, const char *key,
+                                   opal_cstring_t **value, int *flag);
+
+static int get_current_info_value (ompio_file_t *fh, const char *key,
+                                   opal_cstring_t **value, int *flag)
+{
+    int ret;
+
+    *flag = 0;
+    *value = NULL;
+
+    if (NULL != fh->f_info) {
+        ret = opal_info_get(fh->f_info, key, value, flag);
+        if (OPAL_SUCCESS != ret) {
+            return ret;
+        }
+    }
+
+    return OMPI_SUCCESS;
+}
+
 static int datatype_duplicate  (ompi_datatype_t *oldtype, ompi_datatype_t **newtype )
 {
     ompi_datatype_t *type;
@@ -47,8 +70,8 @@ static int datatype_duplicate  (ompi_datatype_t *oldtype, ompi_datatype_t **newt
         ompi_datatype_destroy (&type);
         return MPI_ERR_INTERN;
     }
-    
-    ompi_datatype_set_args( type, 0, NULL, 0, NULL, 1, &oldtype, MPI_COMBINER_DUP );
+
+    ompi_datatype_set_args( type, 0, 0, NULL, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype, MPI_COMBINER_DUP );
 
     *newtype = type;
     return OMPI_SUCCESS;
@@ -70,7 +93,9 @@ int mca_common_ompio_set_view (ompio_file_t *fh,
                                ompi_datatype_t *etype,
                                ompi_datatype_t *filetype,
                                const char *datarep,
-                               opal_info_t *info)
+                               /* Info hints are applied by the caller through the
+                                * subscription path before this helper runs. */
+                               opal_info_t *info __opal_attribute_unused__)
 {
     int ret=OMPI_SUCCESS;
     size_t max_data = 0;
@@ -220,24 +245,15 @@ int mca_common_ompio_set_view (ompio_file_t *fh,
     }
 
     opal_cstring_t *stripe_str;
-    /* Check the info object set during File_open */
-    opal_info_get (info, "cb_nodes", &stripe_str, &flag);
+    ret = get_current_info_value(fh, "cb_nodes", &stripe_str, &flag);
+    if (OMPI_SUCCESS != ret) {
+        goto exit;
+    }
     if ( flag ) {
         sscanf ( stripe_str->string, "%d", &num_cb_nodes );
         OMPIO_MCA_PRINT_INFO(fh, "cb_nodes", stripe_str->string, "");
-        /* add the key/value to the file's info object */
-        opal_info_set_cstring(fh->f_info, "cb_nodes", stripe_str);
         OBJ_RELEASE(stripe_str);
     }
-    else {
-        /* Check the info object set during file_set_view */
-        opal_info_get (fh->f_info, "cb_nodes", &stripe_str, &flag);
-        if ( flag ) {
-            sscanf ( stripe_str->string, "%d", &num_cb_nodes );
-            OMPIO_MCA_PRINT_INFO(fh, "cb_nodes", stripe_str->string, "");
-            OBJ_RELEASE(stripe_str);
-        }
-    }
         
 
     if ( -1 != OMPIO_MCA_GET(fh, num_aggregators) || -1 != num_cb_nodes) {
@@ -326,7 +342,10 @@ int mca_common_ompio_set_view (ompio_file_t *fh,
     }
 
     bool info_is_set=false;
-    opal_info_get (info, "collective_buffering", &stripe_str, &flag);
+    ret = get_current_info_value(fh, "collective_buffering", &stripe_str, &flag);
+    if (OMPI_SUCCESS != ret) {
+        goto exit;
+    }
     if ( flag ) {
         if ( 0 == strncasecmp(stripe_str->string, "false", 5) ){
             info_is_set = true;
@@ -334,20 +353,7 @@ int mca_common_ompio_set_view (ompio_file_t *fh,
         } else {
             OMPIO_MCA_PRINT_INFO(fh, "collective_buffering", stripe_str->string, "");
         }
-        /* add the key/value to the file's info object */
-        opal_info_set_cstring(fh->f_info, "collective_buffering", stripe_str);
         OBJ_RELEASE(stripe_str);
-    } else {
-        opal_info_get (fh->f_info, "collective_buffering", &stripe_str, &flag);
-        if ( flag ) {
-            if ( 0 == strncasecmp(stripe_str->string, "false", 5) ){
-                info_is_set = true;
-                OMPIO_MCA_PRINT_INFO(fh, "collective_buffering", stripe_str->string, "enforcing using individual fcoll component");
-            } else {
-                OMPIO_MCA_PRINT_INFO(fh, "collective_buffering", stripe_str->string, "");
-            }
-            OBJ_RELEASE(stripe_str);
-        }
     }
 
     mca_fcoll_base_component_t *preferred =NULL;
diff --git a/ompi/mca/common/ubcl/Makefile.am b/ompi/mca/common/ubcl/Makefile.am
index 0cd4eb083ef..8e97d16ccdc 100644
--- a/ompi/mca/common/ubcl/Makefile.am
+++ b/ompi/mca/common/ubcl/Makefile.am
@@ -1,4 +1,4 @@
-# Copyright (c) 2025      Bull SAS.  All rights reserved.
+# Copyright (c) 2025-2026 Bull SAS.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -8,7 +8,7 @@
 
 #AM_CPPFLAGS = $(common_ubcl_CPPFLAGS)
 
-common_ubcl_sources  = \
+ompi_common_ubcl_sources  = \
 	common_ubcl.c \
 	common_ubcl.h
 
@@ -27,14 +27,16 @@ else
 noinst_LTLIBRARIES += $(comp_noinst)
 endif
 
-libmca_common_ubcl_la_SOURCES = $(common_ubcl_sources)
-libmca_common_ubcl_la_CFLAGS = $(common_ubcl_CFLAGS)
-libmca_common_ubcl_la_CPPFLAGS = $(common_ubcl_CPPFLAGS)
-libmca_common_ubcl_la_LDFLAGS = $(common_ubcl_LDFLAGS)
-libmca_common_ubcl_la_LIBADD = $(common_ubcl_LIBS) \
+libmca_common_ubcl_la_SOURCES = $(ompi_common_ubcl_sources)
+libmca_common_ubcl_la_CFLAGS = $(ompi_common_ubcl_CFLAGS)
+libmca_common_ubcl_la_CPPFLAGS = $(ompi_common_ubcl_CPPFLAGS)
+libmca_common_ubcl_la_LDFLAGS = $(ompi_common_ubcl_LDFLAGS)
+libmca_common_ubcl_la_LIBADD = $(ompi_common_ubcl_LIBS) \
 	$(OPAL_TOP_BUILDDIR)/opal/mca/common/ubcl/lib@OPAL_LIB_NAME@mca_common_ubcl.la
 
-libmca_common_ubcl_noinst_la_SOURCES = $(common_ubcl_sources)
+libmca_common_ubcl_noinst_la_SOURCES = $(ompi_common_ubcl_sources)
+libmca_common_ubcl_noinst_la_CPPFLAGS = $(ompi_common_ubcl_CPPFLAGS)
+libmca_common_ubcl_noinst_la_LDFLAGS = $(ompi_common_ubcl_LDFLAGS)
 
 # Conditionally install the header files
 
diff --git a/ompi/mca/common/ubcl/configure.m4 b/ompi/mca/common/ubcl/configure.m4
index 42ba29cf67a..76000dbc7e3 100644
--- a/ompi/mca/common/ubcl/configure.m4
+++ b/ompi/mca/common/ubcl/configure.m4
@@ -1,6 +1,6 @@
 # -*- shell-script -*-
 #
-# Copyright (c) 2025      Bull S.A.S. All rights reserved.
+# Copyright (c) 2025-2026 Bull S.A.S. All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -15,6 +15,24 @@ AC_DEFUN([MCA_ompi_common_ubcl_CONFIG],[
                     [common_ubcl_happy="yes"],
                     [common_ubcl_happy="no"])
 
+    # By default the tarball build goes through a 'make dist check' step.
+    # It runs first a configure without any options and OMPI_CHECK_UBCL may find UBCL.
+    # In that case, UBCL symbols will be included inside binaries such as ompi_info,
+    # therefore UBCL linking flags are needed in static mode to resolve symbols.
+    #
+    # In dynamic mode, UBCL symbols are resolved at runtime: ompi components
+    # are dlopen-ed lazily and UBCL components initialization starts with a dlopen
+    # of libubcl.so to load symbols. If it fails UBCL components init returns an error and
+    # Open MPI will search for other components. UBCL linking flags become optional.
+    #
+    # In dynamic mode, linking to the UBCL library is delayed. So common/ubcl can let
+    # endusers provide a more recent version of UBCL.
+    # This mode should be preferably selected for UBCL components.
+    # An mca parameter is exposed to select a specific UBCL path that is dlopen
+    # at runtime.
+    AS_IF([test "$compile_mode" = "dso"],
+          [common_ubcl_LDFLAGS=""],
+          [AC_MSG_WARN([Only DSO mode of common/ubcl is tested (see --enable-mca-dso)])])
 
     AC_REQUIRE([MCA_opal_common_ubcl_CONFIG])
 
@@ -23,7 +41,7 @@ AC_DEFUN([MCA_ompi_common_ubcl_CONFIG],[
           [$2])
 
     # substitute in the things needed to build ubcl
-    AC_SUBST([common_ubcl_CPPFLAGS])
-    AC_SUBST([common_ubcl_LDFLAGS])
-    AC_SUBST([common_ubcl_LIBS])
+    AC_SUBST([ompi_common_ubcl_CPPFLAGS])
+    AC_SUBST([ompi_common_ubcl_LDFLAGS])
+    AC_SUBST([ompi_common_ubcl_LIBS])
 ])dnl
diff --git a/ompi/mca/fcoll/base/fcoll_base_coll_array.c b/ompi/mca/fcoll/base/fcoll_base_coll_array.c
index 68f25ace6fb..6f888c1dd29 100644
--- a/ompi/mca/fcoll/base/fcoll_base_coll_array.c
+++ b/ompi/mca/fcoll/base/fcoll_base_coll_array.c
@@ -14,6 +14,7 @@
  * Copyright (c) 2017      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2017      IBM Corporation. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -50,7 +51,6 @@ int ompi_fcoll_base_coll_allgatherv_array (void *sbuf,
     int err = OMPI_SUCCESS;
     ptrdiff_t extent, lb;
     int i, rank, j;
-    int *tmp_rcounts = NULL, *tmp_disps = NULL;
     char *send_buf = NULL;
     struct ompi_datatype_t *newtype, *send_type;
 
@@ -93,24 +93,11 @@ int ompi_fcoll_base_coll_allgatherv_array (void *sbuf,
         return err;
     }
 
-    /* TODO:BIGCOUNT: remove tmp_rcounts and tmp_disps once the ompi_datatype
-     * interface is udpated to use size_t/ptrdiff_t
-     */
-    tmp_rcounts = (int *)malloc(2 * procs_per_group * sizeof(int));
-    if (NULL == tmp_rcounts) {
-        return OMPI_ERR_OUT_OF_RESOURCE;
-    }
-    tmp_disps = tmp_rcounts + procs_per_group;
-    for (i = 0; i < procs_per_group; i++) {
-        tmp_rcounts[i] = (int) rcounts[i];
-        tmp_disps[i] = (int) disps[i];
-    }
     err = ompi_datatype_create_indexed (procs_per_group,
-                                        tmp_rcounts,
-                                        tmp_disps,
+                                        OMPI_COUNT_ARRAY_CREATE(rcounts),
+                                        OMPI_DISP_ARRAY_CREATE(disps),
                                         rdtype,
                                         &newtype);
-    free(tmp_rcounts);
     if (MPI_SUCCESS != err) {
         return err;
     }
diff --git a/ompi/mca/fcoll/dynamic/fcoll_dynamic_file_write_all.c b/ompi/mca/fcoll/dynamic/fcoll_dynamic_file_write_all.c
index 2ce3ef5d27f..0560bdbe2c4 100644
--- a/ompi/mca/fcoll/dynamic/fcoll_dynamic_file_write_all.c
+++ b/ompi/mca/fcoll/dynamic/fcoll_dynamic_file_write_all.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2023      Jeffrey M. Squyres.  All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -784,8 +785,8 @@ mca_fcoll_dynamic_file_write_all (struct ompio_file_t *fh,
                 recv_req[i] = MPI_REQUEST_NULL;
                 if ( 0 < disp_index[i] ) {
                     ompi_datatype_create_hindexed(disp_index[i],
-                                                  blocklen_per_process[i],
-                                                  displs_per_process[i],
+                                                  OMPI_COUNT_ARRAY_CREATE(blocklen_per_process[i]),
+                                                  OMPI_DISP_ARRAY_CREATE(displs_per_process[i]),
                                                   MPI_BYTE,
                                                   &recvtype[i]);
                     ompi_datatype_commit(&recvtype[i]);
diff --git a/ompi/mca/fcoll/dynamic_gen2/fcoll_dynamic_gen2_file_write_all.c b/ompi/mca/fcoll/dynamic_gen2/fcoll_dynamic_gen2_file_write_all.c
index 1f9b5f8bef7..bcd5195148b 100644
--- a/ompi/mca/fcoll/dynamic_gen2/fcoll_dynamic_gen2_file_write_all.c
+++ b/ompi/mca/fcoll/dynamic_gen2/fcoll_dynamic_gen2_file_write_all.c
@@ -17,6 +17,7 @@
  * Copyright (c) 2023      Jeffrey M. Squyres.  All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -1160,13 +1161,13 @@ static int shuffle_init ( int index, int cycles, int aggregator, int rank, mca_i
                 reqs[i] = MPI_REQUEST_NULL;
                 if ( 0 < data->disp_index[i] ) {
                     ompi_datatype_create_hindexed(data->disp_index[i],
-                                                  data->blocklen_per_process[i],
-                                                  data->displs_per_process[i],
+                                                  OMPI_COUNT_ARRAY_CREATE(data->blocklen_per_process[i]),
+                                                  OMPI_DISP_ARRAY_CREATE(data->displs_per_process[i]),
                                                   MPI_BYTE,
                                                   &data->recvtype[i]);
                     ompi_datatype_commit(&data->recvtype[i]);
                     opal_datatype_type_size(&data->recvtype[i]->super, &datatype_size);
-                    
+
                     if (datatype_size){
                         ret = MCA_PML_CALL(irecv(data->global_buf,
                                                  1,
@@ -1240,8 +1241,8 @@ static int shuffle_init ( int index, int cycles, int aggregator, int rank, mca_i
 
         if ( 0 <= block_index ) {
             ompi_datatype_create_hindexed(block_index+1,
-                                          blocklength_proc,
-                                          displs_proc,
+                                          OMPI_COUNT_ARRAY_CREATE(blocklength_proc),
+                                          OMPI_DISP_ARRAY_CREATE(displs_proc),
                                           MPI_BYTE,
                                           &newType);
             ompi_datatype_commit(&newType);
diff --git a/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_read_all.c b/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_read_all.c
index f6a492e621c..ebef7b3cb92 100644
--- a/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_read_all.c
+++ b/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_read_all.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2024      Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -840,8 +841,8 @@ static int shuffle_init (int index, int cycles, int aggregator, int rank, mca_io
             reqs[i] = MPI_REQUEST_NULL;
 	    if (0 < data->disp_index[i]) {
 		ompi_datatype_create_hindexed (data->disp_index[i],
-					       data->blocklen_per_process[i],
-					       data->displs_per_process[i],
+					       OMPI_COUNT_ARRAY_CREATE(data->blocklen_per_process[i]),
+					       OMPI_DISP_ARRAY_CREATE(data->displs_per_process[i]),
 					       MPI_BYTE,
 					       &data->recvtype[i]);
 		ompi_datatype_commit (&data->recvtype[i]);
@@ -918,8 +919,8 @@ static int shuffle_init (int index, int cycles, int aggregator, int rank, mca_io
 
         if (0 <= block_index) {
             ompi_datatype_create_hindexed (block_index+1,
-                                           blocklength_proc,
-                                           displs_proc,
+                                           OMPI_COUNT_ARRAY_CREATE(blocklength_proc),
+                                           OMPI_DISP_ARRAY_CREATE(displs_proc),
                                            MPI_BYTE,
                                            &newType);
             ompi_datatype_commit (&newType);
diff --git a/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_write_all.c b/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_write_all.c
index b6e9be6d2ca..61aa8b32920 100644
--- a/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_write_all.c
+++ b/ompi/mca/fcoll/vulcan/fcoll_vulcan_file_write_all.c
@@ -17,6 +17,7 @@
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2024      Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -833,8 +834,8 @@ static int shuffle_init (int index, int num_cycles, int aggregator, int rank,
                 reqs[i] = MPI_REQUEST_NULL;
                 if (0 < data->disp_index[i]) {
                     ompi_datatype_create_hindexed(data->disp_index[i],
-                                                  data->blocklen_per_process[i],
-                                                  data->displs_per_process[i],
+                                                  OMPI_COUNT_ARRAY_CREATE(data->blocklen_per_process[i]),
+                                                  OMPI_DISP_ARRAY_CREATE(data->displs_per_process[i]),
                                                   MPI_BYTE,
                                                   &data->recvtype[i]);
                     ompi_datatype_commit(&data->recvtype[i]);
@@ -909,8 +910,8 @@ static int shuffle_init (int index, int num_cycles, int aggregator, int rank,
 
         if ( 0 <= block_index ) {
             ompi_datatype_create_hindexed(block_index+1,
-                                          blocklength_proc,
-                                          displs_proc,
+                                          OMPI_COUNT_ARRAY_CREATE(blocklength_proc),
+                                          OMPI_DISP_ARRAY_CREATE(displs_proc),
                                           MPI_BYTE,
                                           &newType);
             ompi_datatype_commit(&newType);
diff --git a/ompi/mca/fs/gpfs/fs_gpfs.c b/ompi/mca/fs/gpfs/fs_gpfs.c
index a1bf194f3e3..46c42b56e58 100644
--- a/ompi/mca/fs/gpfs/fs_gpfs.c
+++ b/ompi/mca/fs/gpfs/fs_gpfs.c
@@ -12,6 +12,7 @@
  * Copyright (c) 2008-2018 University of Houston. All rights reserved.
  * Copyright (c) 2018      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -138,5 +139,6 @@ int mca_fs_gpfs_module_init (ompio_file_t *file)
 
 int mca_fs_gpfs_module_finalize (ompio_file_t *file)
 {
+    mca_fs_gpfs_info_cache_free(file);
     return OMPI_SUCCESS;
 }
diff --git a/ompi/mca/fs/gpfs/fs_gpfs.h b/ompi/mca/fs/gpfs/fs_gpfs.h
index f34de540a7b..2d5bdf11a68 100644
--- a/ompi/mca/fs/gpfs/fs_gpfs.h
+++ b/ompi/mca/fs/gpfs/fs_gpfs.h
@@ -11,6 +11,7 @@
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
  * Copyright (c) 2008-2012 University of Houston. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  * 
  * Additional copyrights may follow
@@ -40,6 +41,7 @@ int mca_fs_gpfs_component_file_unquery(ompio_file_t *file);
 
 int mca_fs_gpfs_module_init(ompio_file_t *file);
 int mca_fs_gpfs_module_finalize(ompio_file_t *file);
+void mca_fs_gpfs_info_cache_free(ompio_file_t *file);
 OMPI_DECLSPEC extern mca_fs_base_component_2_0_0_t mca_fs_gpfs_component;
 
 /*
diff --git a/ompi/mca/fs/gpfs/fs_gpfs_file_open.c b/ompi/mca/fs/gpfs/fs_gpfs_file_open.c
index 497bc402f7a..78f80921e8f 100644
--- a/ompi/mca/fs/gpfs/fs_gpfs_file_open.c
+++ b/ompi/mca/fs/gpfs/fs_gpfs_file_open.c
@@ -10,6 +10,7 @@
  *  Copyright (c) 2004-2005 The Regents of the University of California.
  *                          All rights reserved.
  *  Copyright (c) 2008-2012 University of Houston. All rights reserved.
+ *  Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  *  $COPYRIGHT$
  *  
  *  Additional copyrights may follow
@@ -38,6 +39,332 @@
 #include <fcntl.h>
 #include <errno.h>
 #include <gpfs_fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct mca_fs_gpfs_info_cache_t {
+    char *use_siox_lib;
+    char *gpfs_access_range;
+    char *gpfs_free_range;
+    char *gpfs_clear_file_cache;
+    char *gpfs_cancel_hints;
+    char *gpfs_set_replication;
+    char *gpfs_byte_range;
+    char *gpfs_restripe_data;
+#ifdef HAVE_C_SIOX_H
+    char *siox_access_range;
+    char *siox_free_range;
+    char *siox_clear_file_cache;
+    char *siox_cancel_hints;
+    char *siox_data_ship_start;
+    char *siox_data_ship_stop;
+    char *siox_set_replication;
+    char *siox_byte_range;
+    char *siox_restripe_data;
+#endif
+};
+
+static const char *const mca_fs_gpfs_hints[] = {
+    "useSIOXLib",
+    "gpfsAccessRange",
+    "gpfsFreeRange",
+    "gpfsClearFileCache",
+    "gpfsCancelHints",
+    "gpfsSetReplication",
+    "gpfsByteRange",
+    "gpfsRestripeData",
+    NULL
+};
+
+#ifdef HAVE_C_SIOX_H
+static const char *const mca_fs_gpfs_siox_hints[] = {
+    "sioxAccessRange",
+    "sioxFreeRange",
+    "sioxClearFileCache",
+    "sioxCancelHints",
+    "sioxDataShipStart",
+    "sioxDataShipStop",
+    "sioxSetReplication",
+    "sioxByteRange",
+    "sioxRestripeData",
+    NULL
+};
+#endif
+
+/*
+ * GPFS hint names are intentionally registered only in the GPFS component.
+ * Keep the cache keyed by the public hint strings so callback registration,
+ * open-time remember logic, and final cleanup all agree on ownership without
+ * teaching OMPIO common code about GPFS-specific names.
+ */
+static char **mca_fs_gpfs_info_cache_slot(ompio_file_t *fh, const char *key)
+{
+    struct mca_fs_gpfs_info_cache_t *cache;
+
+    if (NULL == fh || NULL == fh->f_fs_ptr || NULL == key) {
+        return NULL;
+    }
+
+    cache = (struct mca_fs_gpfs_info_cache_t *) fh->f_fs_ptr;
+    if (0 == strcmp(key, "useSIOXLib")) {
+        return &cache->use_siox_lib;
+    }
+    if (0 == strcmp(key, "gpfsAccessRange")) {
+        return &cache->gpfs_access_range;
+    }
+    if (0 == strcmp(key, "gpfsFreeRange")) {
+        return &cache->gpfs_free_range;
+    }
+    if (0 == strcmp(key, "gpfsClearFileCache")) {
+        return &cache->gpfs_clear_file_cache;
+    }
+    if (0 == strcmp(key, "gpfsCancelHints")) {
+        return &cache->gpfs_cancel_hints;
+    }
+    if (0 == strcmp(key, "gpfsSetReplication")) {
+        return &cache->gpfs_set_replication;
+    }
+    if (0 == strcmp(key, "gpfsByteRange")) {
+        return &cache->gpfs_byte_range;
+    }
+    if (0 == strcmp(key, "gpfsRestripeData")) {
+        return &cache->gpfs_restripe_data;
+    }
+#ifdef HAVE_C_SIOX_H
+    if (0 == strcmp(key, "sioxAccessRange")) {
+        return &cache->siox_access_range;
+    }
+    if (0 == strcmp(key, "sioxFreeRange")) {
+        return &cache->siox_free_range;
+    }
+    if (0 == strcmp(key, "sioxClearFileCache")) {
+        return &cache->siox_clear_file_cache;
+    }
+    if (0 == strcmp(key, "sioxCancelHints")) {
+        return &cache->siox_cancel_hints;
+    }
+    if (0 == strcmp(key, "sioxDataShipStart")) {
+        return &cache->siox_data_ship_start;
+    }
+    if (0 == strcmp(key, "sioxDataShipStop")) {
+        return &cache->siox_data_ship_stop;
+    }
+    if (0 == strcmp(key, "sioxSetReplication")) {
+        return &cache->siox_set_replication;
+    }
+    if (0 == strcmp(key, "sioxByteRange")) {
+        return &cache->siox_byte_range;
+    }
+    if (0 == strcmp(key, "sioxRestripeData")) {
+        return &cache->siox_restripe_data;
+    }
+#endif
+
+    return NULL;
+}
+
+static const char *mca_fs_gpfs_get_cached_info(ompio_file_t *fh, const char *key)
+{
+    char **slot;
+
+    slot = mca_fs_gpfs_info_cache_slot(fh, key);
+    if (NULL == slot) {
+        return NULL;
+    }
+
+    return *slot;
+}
+
+static int mca_fs_gpfs_info_cache_alloc(ompio_file_t *fh)
+{
+    if (NULL == fh) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    if (NULL != fh->f_fs_ptr) {
+        return OMPI_SUCCESS;
+    }
+
+    fh->f_fs_ptr = calloc(1, sizeof(struct mca_fs_gpfs_info_cache_t));
+    if (NULL == fh->f_fs_ptr) {
+        return OMPI_ERR_OUT_OF_RESOURCE;
+    }
+
+    return OMPI_SUCCESS;
+}
+
+static int mca_fs_gpfs_remember_info(ompio_file_t *fh, const char *key)
+{
+    char **slot;
+    char *copy;
+    int flag;
+    opal_cstring_t *value_str;
+
+    slot = mca_fs_gpfs_info_cache_slot(fh, key);
+    if (NULL == slot) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    opal_info_get(fh->f_info, key, &value_str, &flag);
+    if (!flag) {
+        return OMPI_SUCCESS;
+    }
+
+    /*
+     * The subscriber callback can only return borrowed/static storage.
+     * Store a per-file copy of each accepted open-time value so callbacks
+     * during later phases can return the actual value that was applied.
+     */
+    copy = strdup(value_str->string);
+    OBJ_RELEASE(value_str);
+    if (NULL == copy) {
+        return OMPI_ERR_OUT_OF_RESOURCE;
+    }
+
+    free(*slot);
+    *slot = copy;
+    return OMPI_SUCCESS;
+}
+
+void mca_fs_gpfs_info_cache_free(ompio_file_t *file)
+{
+    struct mca_fs_gpfs_info_cache_t *cache;
+
+    if (NULL == file || NULL == file->f_fs_ptr) {
+        return;
+    }
+
+    cache = (struct mca_fs_gpfs_info_cache_t *) file->f_fs_ptr;
+    free(cache->use_siox_lib);
+    free(cache->gpfs_access_range);
+    free(cache->gpfs_free_range);
+    free(cache->gpfs_clear_file_cache);
+    free(cache->gpfs_cancel_hints);
+    free(cache->gpfs_set_replication);
+    free(cache->gpfs_byte_range);
+    free(cache->gpfs_restripe_data);
+#ifdef HAVE_C_SIOX_H
+    free(cache->siox_access_range);
+    free(cache->siox_free_range);
+    free(cache->siox_clear_file_cache);
+    free(cache->siox_cancel_hints);
+    free(cache->siox_data_ship_start);
+    free(cache->siox_data_ship_stop);
+    free(cache->siox_set_replication);
+    free(cache->siox_byte_range);
+    free(cache->siox_restripe_data);
+#endif
+    free(cache);
+    file->f_fs_ptr = NULL;
+}
+
+static const char *mca_fs_gpfs_hint_cb(opal_infosubscriber_t *object,
+                                       const char *key,
+                                       const char *value)
+{
+    ompi_file_t *file;
+    mca_common_ompio_data_t *data;
+    ompio_file_t *fh;
+
+    if (NULL == object || NULL == key || NULL == value) {
+        return NULL;
+    }
+
+    file = (ompi_file_t *) object;
+    data = (mca_common_ompio_data_t *) file->f_io_selected_data;
+    if (NULL == data) {
+        return NULL;
+    }
+    fh = &data->ompio_fh;
+
+    /*
+     * The existing GPFS code applies these hints only during file open.
+     * Later MPI_File_set_info or MPI_File_set_view calls should not make a
+     * new value public unless GPFS actually consumed it, so report the
+     * cached open-time value outside the OPEN phase.
+     */
+    if (MCA_COMMON_OMPIO_INFO_PHASE_OPEN != fh->f_info_phase) {
+        return mca_fs_gpfs_get_cached_info(fh, key);
+    }
+
+    if ('\0' == value[0]) {
+        return NULL;
+    }
+
+    return value;
+}
+
+static int mca_fs_gpfs_subscribe_hints(ompio_file_t *fh, const char *const *hints)
+{
+    int ret;
+
+    for (int i = 0; NULL != hints[i]; ++i) {
+        ret = mca_common_ompio_info_subscribe(fh, hints[i], NULL,
+                                              mca_fs_gpfs_hint_cb);
+        if (OMPI_SUCCESS != ret) {
+            return ret;
+        }
+    }
+
+    return OMPI_SUCCESS;
+}
+
+static int mca_fs_gpfs_remember_hints(ompio_file_t *fh, const char *const *hints)
+{
+    int ret;
+
+    for (int i = 0; NULL != hints[i]; ++i) {
+        ret = mca_fs_gpfs_remember_info(fh, hints[i]);
+        if (OMPI_SUCCESS != ret) {
+            return ret;
+        }
+    }
+
+    return OMPI_SUCCESS;
+}
+
+static int mca_fs_gpfs_register_info(ompio_file_t *fh)
+{
+    int ret;
+
+    ret = mca_fs_gpfs_subscribe_hints(fh, mca_fs_gpfs_hints);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+#ifdef HAVE_C_SIOX_H
+    ret = mca_fs_gpfs_subscribe_hints(fh, mca_fs_gpfs_siox_hints);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+#endif
+
+    return OMPI_SUCCESS;
+}
+
+static int mca_fs_gpfs_cache_info(ompio_file_t *fh)
+{
+    int ret;
+
+    /*
+     * Registration makes supported keys public; this second pass records
+     * only the values that survived registration so get_info remains tied
+     * to what the component accepted.
+     */
+    ret = mca_fs_gpfs_remember_hints(fh, mca_fs_gpfs_hints);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+#ifdef HAVE_C_SIOX_H
+    ret = mca_fs_gpfs_remember_hints(fh, mca_fs_gpfs_siox_hints);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+#endif
+
+    return OMPI_SUCCESS;
+}
 
 int
 mca_fs_gpfs_file_open (struct ompi_communicator_t *comm,
@@ -52,6 +379,21 @@ mca_fs_gpfs_file_open (struct ompi_communicator_t *comm,
     perm = mca_fs_base_get_file_perm(fh);
     amode = mca_fs_base_get_file_amode(fh->f_rank, access_mode);
 
+    ret = mca_fs_gpfs_info_cache_alloc(fh);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    ret = mca_fs_gpfs_register_info(fh);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    ret = mca_fs_gpfs_cache_info(fh);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
     if(OMPIO_ROOT == fh->f_rank) {
         fh->fd = open (filename, amode, perm);
         if ( 0 > fh->fd ) {
diff --git a/ompi/mca/fs/lustre/fs_lustre.c b/ompi/mca/fs/lustre/fs_lustre.c
index 494114416b4..139b3b75efb 100644
--- a/ompi/mca/fs/lustre/fs_lustre.c
+++ b/ompi/mca/fs/lustre/fs_lustre.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2018      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2018      DataDirect Networks. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -125,5 +126,6 @@ int mca_fs_lustre_module_init (ompio_file_t *file)
 
 int mca_fs_lustre_module_finalize (ompio_file_t *file)
 {
+    mca_fs_lustre_info_cache_free(file);
     return OMPI_SUCCESS;
 }
diff --git a/ompi/mca/fs/lustre/fs_lustre.h b/ompi/mca/fs/lustre/fs_lustre.h
index ebd9da168b7..dcdabe1b127 100644
--- a/ompi/mca/fs/lustre/fs_lustre.h
+++ b/ompi/mca/fs/lustre/fs_lustre.h
@@ -14,6 +14,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
  * Copyright (c) 2024      Advanced Micro Devices, Inc. All rights reserverd.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -57,6 +58,7 @@ int mca_fs_lustre_component_file_unquery (ompio_file_t *file);
 
 int mca_fs_lustre_module_init (ompio_file_t *file);
 int mca_fs_lustre_module_finalize (ompio_file_t *file);
+void mca_fs_lustre_info_cache_free (ompio_file_t *file);
 
 OMPI_DECLSPEC extern mca_fs_base_component_2_0_0_t mca_fs_lustre_component;
 /*
diff --git a/ompi/mca/fs/lustre/fs_lustre_file_open.c b/ompi/mca/fs/lustre/fs_lustre_file_open.c
index 9318825987e..e9c9b8c2d0d 100644
--- a/ompi/mca/fs/lustre/fs_lustre_file_open.c
+++ b/ompi/mca/fs/lustre/fs_lustre_file_open.c
@@ -14,6 +14,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
  * Copyright (c) 2024      Advanced Micro Devices, Inc. All rights reserverd.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -35,8 +36,34 @@
 #include "ompi/info/info.h"
 
 #include <sys/ioctl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 static void *alloc_lum(void);
+struct mca_fs_lustre_info_cache_t;
+static const char *mca_fs_lustre_layout_hint_cb(opal_infosubscriber_t *object,
+                                                const char *key,
+                                                const char *value);
+static const char *mca_fs_lustre_stripe_size_cb(opal_infosubscriber_t *object,
+                                                const char *key,
+                                                const char *value);
+static const char *mca_fs_lustre_stripe_width_cb(opal_infosubscriber_t *object,
+                                                 const char *key,
+                                                 const char *value);
+static const char *mca_fs_lustre_get_cached_info(ompio_file_t *fh,
+                                                 const char *key);
+static bool mca_fs_lustre_info_has_key(opal_infosubscriber_t *object,
+                                       const char *key);
+static int mca_fs_lustre_info_cache_alloc(ompio_file_t *fh);
+static int mca_fs_lustre_remember_info(ompio_file_t *fh, const char *key);
+static int mca_fs_lustre_remember_info_value(ompio_file_t *fh, const char *key,
+                                             const char *value);
+static int mca_fs_lustre_register_info(ompio_file_t *fh);
+static int mca_fs_lustre_parse_int_hint(opal_info_t *info, const char *key,
+                                        int *value);
+static int mca_fs_lustre_set_default_hint(ompio_file_t *fh, const char *key,
+                                          int value);
 
 static void *alloc_lum(void)
 {
@@ -50,6 +77,290 @@ static void *alloc_lum(void)
   return malloc(MAX(v1, v3));
 }
 
+struct mca_fs_lustre_info_cache_t {
+    char *striping_unit;
+    char *striping_factor;
+    char *stripe_size;
+    char *stripe_width;
+};
+
+/*
+ * Lustre layout hints are consumed while creating/opening the file.  They
+ * cannot be safely applied later to an already-open file, so post-open
+ * callbacks return the open-time cached value instead of the new user value.
+ * Returning NULL tells the subscriber layer that the new value was not
+ * accepted and therefore must not become public in MPI_File_get_info.
+ */
+static const char *mca_fs_lustre_layout_hint_cb(opal_infosubscriber_t *object,
+                                                const char *key,
+                                                const char *value)
+{
+    ompi_file_t *file;
+    mca_common_ompio_data_t *data;
+    ompio_file_t *fh;
+
+    if (NULL == object || NULL == key || NULL == value) {
+        return NULL;
+    }
+
+    file = (ompi_file_t *) object;
+    data = (mca_common_ompio_data_t *) file->f_io_selected_data;
+    if (NULL == data) {
+        return NULL;
+    }
+    fh = &data->ompio_fh;
+
+    if (MCA_COMMON_OMPIO_INFO_PHASE_OPEN != fh->f_info_phase) {
+        return mca_fs_lustre_get_cached_info(fh, key);
+    }
+
+    if ('\0' == value[0]) {
+        return NULL;
+    }
+
+    return value;
+}
+
+static bool mca_fs_lustre_info_has_key(opal_infosubscriber_t *object,
+                                       const char *key)
+{
+    int flag;
+    opal_cstring_t *value;
+
+    if (NULL == object || NULL == object->s_info || NULL == key) {
+        return false;
+    }
+
+    opal_info_get(object->s_info, key, &value, &flag);
+    if (!flag) {
+        return false;
+    }
+
+    OBJ_RELEASE(value);
+    return true;
+}
+
+static const char *mca_fs_lustre_stripe_size_cb(opal_infosubscriber_t *object,
+                                                const char *key,
+                                                const char *value)
+{
+    /*
+     * If both MPI-IO canonical spelling and the older OMPIO alias are
+     * present, keep the canonical key public.  This preserves the existing
+     * parser precedence and gives get_info a single accepted spelling.
+     */
+    if (mca_fs_lustre_info_has_key(object, "striping_unit")) {
+        return NULL;
+    }
+
+    return mca_fs_lustre_layout_hint_cb(object, key, value);
+}
+
+static const char *mca_fs_lustre_stripe_width_cb(opal_infosubscriber_t *object,
+                                                 const char *key,
+                                                 const char *value)
+{
+    /*
+     * Same rule as stripe_size: the MPI spelling wins over the historical
+     * alias when both are supplied.
+     */
+    if (mca_fs_lustre_info_has_key(object, "striping_factor")) {
+        return NULL;
+    }
+
+    return mca_fs_lustre_layout_hint_cb(object, key, value);
+}
+
+static char **mca_fs_lustre_info_cache_slot(ompio_file_t *fh, const char *key)
+{
+    struct mca_fs_lustre_info_cache_t *cache;
+
+    if (NULL == fh || NULL == fh->f_fs_ptr || NULL == key) {
+        return NULL;
+    }
+
+    cache = (struct mca_fs_lustre_info_cache_t *) fh->f_fs_ptr;
+    if (0 == strcmp(key, "striping_unit")) {
+        return &cache->striping_unit;
+    }
+    if (0 == strcmp(key, "striping_factor")) {
+        return &cache->striping_factor;
+    }
+    if (0 == strcmp(key, "stripe_size")) {
+        return &cache->stripe_size;
+    }
+    if (0 == strcmp(key, "stripe_width")) {
+        return &cache->stripe_width;
+    }
+
+    return NULL;
+}
+
+static const char *mca_fs_lustre_get_cached_info(ompio_file_t *fh,
+                                                 const char *key)
+{
+    char **slot;
+
+    slot = mca_fs_lustre_info_cache_slot(fh, key);
+    if (NULL == slot) {
+        return NULL;
+    }
+
+    return *slot;
+}
+
+static int mca_fs_lustre_info_cache_alloc(ompio_file_t *fh)
+{
+    if (NULL == fh) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    if (NULL != fh->f_fs_ptr) {
+        return OMPI_SUCCESS;
+    }
+
+    fh->f_fs_ptr = calloc(1, sizeof(struct mca_fs_lustre_info_cache_t));
+    if (NULL == fh->f_fs_ptr) {
+        return OMPI_ERR_OUT_OF_RESOURCE;
+    }
+
+    return OMPI_SUCCESS;
+}
+
+static int mca_fs_lustre_remember_info_value(ompio_file_t *fh, const char *key,
+                                             const char *value)
+{
+    char **slot;
+    char *copy;
+
+    if (NULL == value) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    slot = mca_fs_lustre_info_cache_slot(fh, key);
+    if (NULL == slot) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    copy = strdup(value);
+    if (NULL == copy) {
+        return OMPI_ERR_OUT_OF_RESOURCE;
+    }
+
+    free(*slot);
+    *slot = copy;
+    return OMPI_SUCCESS;
+}
+
+static int mca_fs_lustre_remember_info(ompio_file_t *fh, const char *key)
+{
+    int flag;
+    int ret;
+    opal_cstring_t *value_str;
+
+    opal_info_get(fh->f_info, key, &value_str, &flag);
+    if (!flag) {
+        return OMPI_SUCCESS;
+    }
+
+    ret = mca_fs_lustre_remember_info_value(fh, key, value_str->string);
+    OBJ_RELEASE(value_str);
+    return ret;
+}
+
+void mca_fs_lustre_info_cache_free(ompio_file_t *file)
+{
+    struct mca_fs_lustre_info_cache_t *cache;
+
+    if (NULL == file || NULL == file->f_fs_ptr) {
+        return;
+    }
+
+    cache = (struct mca_fs_lustre_info_cache_t *) file->f_fs_ptr;
+    free(cache->striping_unit);
+    free(cache->striping_factor);
+    free(cache->stripe_size);
+    free(cache->stripe_width);
+    free(cache);
+    file->f_fs_ptr = NULL;
+}
+
+static int mca_fs_lustre_register_info(ompio_file_t *fh)
+{
+    int ret;
+
+    ret = mca_common_ompio_info_subscribe(fh, "striping_unit", NULL,
+                                          mca_fs_lustre_layout_hint_cb);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    ret = mca_common_ompio_info_subscribe(fh, "stripe_size", NULL,
+                                          mca_fs_lustre_stripe_size_cb);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    ret = mca_common_ompio_info_subscribe(fh, "striping_factor", NULL,
+                                          mca_fs_lustre_layout_hint_cb);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    return mca_common_ompio_info_subscribe(fh, "stripe_width", NULL,
+                                           mca_fs_lustre_stripe_width_cb);
+}
+
+static int mca_fs_lustre_parse_int_hint(opal_info_t *info, const char *key,
+                                        int *value)
+{
+    int flag;
+    opal_cstring_t *value_str;
+
+    opal_info_get(info, key, &value_str, &flag);
+    if (!flag) {
+        return 0;
+    }
+
+    if (1 == sscanf(value_str->string, "%d", value)) {
+        OBJ_RELEASE(value_str);
+        return 1;
+    }
+
+    OBJ_RELEASE(value_str);
+    return 0;
+}
+
+static int mca_fs_lustre_set_default_hint(ompio_file_t *fh, const char *key,
+                                          int value)
+{
+    char value_string[32];
+    int ret;
+    int size;
+
+    if (0 >= value) {
+        return OMPI_SUCCESS;
+    }
+
+    size = snprintf(value_string, sizeof(value_string), "%d", value);
+    if (0 > size || sizeof(value_string) <= (size_t) size) {
+        return OMPI_ERR_VALUE_OUT_OF_BOUNDS;
+    }
+
+    ret = mca_common_ompio_info_set(fh, key, value_string);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /*
+     * MCA defaults did not come from the user's MPI_Info, so report them
+     * with the canonical public name.  Cache the same value so later
+     * set_info/set_view attempts cannot overwrite get_info with an
+     * unapplied layout request.
+     */
+    return mca_fs_lustre_remember_info_value(fh, key, value_string);
+}
+
 /*
  *	file_open_lustre
  *
@@ -62,55 +373,88 @@ int
 mca_fs_lustre_file_open (struct ompi_communicator_t *comm,
                      const char* filename,
                      int access_mode,
-                     struct opal_info_t *info,
+                     /* Info hints are applied through the OMPIO subscription
+                      * path; this component reads the accepted values from
+                      * fh->f_info and its private cache. */
+                     struct opal_info_t *info __opal_attribute_unused__,
                      ompio_file_t *fh)
 {
     int amode, perm;
     int rc, ret=OMPI_SUCCESS;
-    int flag;
     int fs_lustre_stripe_size = -1;
     int fs_lustre_stripe_width = -1;
-    opal_cstring_t *stripe_str;
     char *rfilename = (char *)filename;
     struct lov_user_md *lump=NULL;
 
     perm = mca_fs_base_get_file_perm(fh);
     amode = mca_fs_base_get_file_amode(fh->f_rank, access_mode);
 
-    opal_info_get (info, "striping_unit", &stripe_str, &flag);
-    if ( flag ) {
-        sscanf ( stripe_str->string, "%d", &fs_lustre_stripe_size );
-        OBJ_RELEASE(stripe_str);
+    ret = mca_fs_lustre_info_cache_alloc(fh);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
     }
-    else {
-        //internal info object name used earlier. Kept for backwards compatibility.
-        opal_info_get (info, "stripe_size", &stripe_str, &flag);
-        if ( flag ) {
-            sscanf ( stripe_str->string, "%d", &fs_lustre_stripe_size );
-            OBJ_RELEASE(stripe_str);
-        }
+
+    ret = mca_fs_lustre_register_info(fh);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
     }
-    
-    opal_info_get (info, "striping_factor", &stripe_str, &flag);
-    if ( flag ) {
-        sscanf ( stripe_str->string, "%d", &fs_lustre_stripe_width );
-        OBJ_RELEASE(stripe_str);
+
+    /*
+     * Preserve whichever spelling was actually accepted from MPI_Info.
+     * The parser still prefers canonical spellings over aliases to match
+     * the old behavior, but aliases remain visible when they were the
+     * accepted user spelling.
+     */
+    if (mca_fs_lustre_parse_int_hint(fh->f_info, "striping_unit",
+                                     &fs_lustre_stripe_size)) {
+        ret = mca_fs_lustre_remember_info(fh, "striping_unit");
+        if (OMPI_SUCCESS != ret) {
+            return ret;
+        }
+    } else {
+        // internal info object name used earlier. Kept for backwards compatibility.
+        if (mca_fs_lustre_parse_int_hint(fh->f_info, "stripe_size",
+                                         &fs_lustre_stripe_size)) {
+            ret = mca_fs_lustre_remember_info(fh, "stripe_size");
+            if (OMPI_SUCCESS != ret) {
+                return ret;
+            }
+        }
     }
-    else {
-        //internal info object name used earlier. Kept for backwards compatibility.        
-        opal_info_get (info, "stripe_width", &stripe_str, &flag);
-        if ( flag ) {
-            sscanf ( stripe_str->string, "%d", &fs_lustre_stripe_width );
-            OBJ_RELEASE(stripe_str);
+
+    if (mca_fs_lustre_parse_int_hint(fh->f_info, "striping_factor",
+                                     &fs_lustre_stripe_width)) {
+        ret = mca_fs_lustre_remember_info(fh, "striping_factor");
+        if (OMPI_SUCCESS != ret) {
+            return ret;
+        }
+    } else {
+        // internal info object name used earlier. Kept for backwards compatibility.
+        if (mca_fs_lustre_parse_int_hint(fh->f_info, "stripe_width",
+                                         &fs_lustre_stripe_width)) {
+            ret = mca_fs_lustre_remember_info(fh, "stripe_width");
+            if (OMPI_SUCCESS != ret) {
+                return ret;
+            }
         }
     }
-    
+
     if (fs_lustre_stripe_size < 0) {
         fs_lustre_stripe_size = mca_fs_lustre_stripe_size;
+        ret = mca_fs_lustre_set_default_hint(fh, "striping_unit",
+                                             fs_lustre_stripe_size);
+        if (OMPI_SUCCESS != ret) {
+            return ret;
+        }
     }   
 
     if (fs_lustre_stripe_width < 0) {
         fs_lustre_stripe_width = mca_fs_lustre_stripe_width;
+        ret = mca_fs_lustre_set_default_hint(fh, "striping_factor",
+                                             fs_lustre_stripe_width);
+        if (OMPI_SUCCESS != ret) {
+            return ret;
+        }
     }
 
     /* Check for soft links and replace filename by the actual
diff --git a/ompi/mca/io/ompio/io_ompio.c b/ompi/mca/io/ompio/io_ompio.c
index 506b6897e46..bb8ba0a695a 100644
--- a/ompi/mca/io/ompio/io_ompio.c
+++ b/ompi/mca/io/ompio/io_ompio.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2015-2018 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -183,8 +184,8 @@ int ompi_io_ompio_generate_current_file_view (struct ompio_file_t *fh,
             d[i] -= base;
         }
         ompi_datatype_create_struct (3,
-                                     blocklen,
-                                     d,
+                                     OMPI_COUNT_ARRAY_CREATE(blocklen),
+                                     OMPI_DISP_ARRAY_CREATE(d),
                                      types,
                                      &io_array_type);
         ompi_datatype_commit (&io_array_type);
diff --git a/ompi/mca/io/ompio/io_ompio.h b/ompi/mca/io/ompio/io_ompio.h
index d38bfb1acb3..302310966b9 100644
--- a/ompi/mca/io/ompio/io_ompio.h
+++ b/ompi/mca/io/ompio/io_ompio.h
@@ -17,6 +17,7 @@
  * Copyright (c) 2022-2024 Advanced Micro Devices, Inc. All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -162,6 +163,10 @@ int mca_io_ompio_file_get_size (struct ompi_file_t *fh,
                                 OMPI_MPI_OFFSET_TYPE * size);
 int mca_io_ompio_file_get_amode (struct ompi_file_t *fh,
                                  int *amode);
+int mca_io_ompio_file_set_info (struct ompi_file_t *fh,
+                                struct ompi_info_t *info);
+int mca_io_ompio_file_get_info (struct ompi_file_t *fh,
+                                struct ompi_info_t **info_used);
 int mca_io_ompio_file_sync (struct ompi_file_t *fh);
 int mca_io_ompio_file_seek (struct ompi_file_t *fh,
                             OMPI_MPI_OFFSET_TYPE offet,
diff --git a/ompi/mca/io/ompio/io_ompio_file_open.c b/ompi/mca/io/ompio/io_ompio_file_open.c
index 76e4eb6c497..a2e05a91b93 100644
--- a/ompi/mca/io/ompio/io_ompio_file_open.c
+++ b/ompi/mca/io/ompio/io_ompio_file_open.c
@@ -14,6 +14,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2016      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -103,6 +104,56 @@ int mca_io_ompio_file_close (ompi_file_t *fh)
     return ret;
 }
 
+int mca_io_ompio_file_set_info (ompi_file_t *fh,
+                               ompi_info_t *info)
+{
+    int ret;
+    mca_common_ompio_data_t *data;
+    mca_common_ompio_info_phase_t previous_phase;
+
+    if (NULL == fh || NULL == info) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    data = (mca_common_ompio_data_t *) fh->f_io_selected_data;
+    if (NULL == data) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    OPAL_THREAD_LOCK(&fh->f_lock);
+    previous_phase = data->ompio_fh.f_info_phase;
+    data->ompio_fh.f_info_phase = MCA_COMMON_OMPIO_INFO_PHASE_SET_INFO;
+
+    ret = mca_common_ompio_info_apply(&data->ompio_fh, &info->super);
+
+    data->ompio_fh.f_info_phase = previous_phase;
+    OPAL_THREAD_UNLOCK(&fh->f_lock);
+
+    return ret;
+}
+
+int mca_io_ompio_file_get_info (ompi_file_t *fh,
+                               ompi_info_t **info_used)
+{
+    int ret;
+    mca_common_ompio_data_t *data;
+
+    if (NULL == fh || NULL == info_used) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    data = (mca_common_ompio_data_t *) fh->f_io_selected_data;
+    if (NULL == data) {
+        return OMPI_ERR_BAD_PARAM;
+    }
+
+    OPAL_THREAD_LOCK(&fh->f_lock);
+    ret = mca_common_ompio_info_dup(&data->ompio_fh, info_used);
+    OPAL_THREAD_UNLOCK(&fh->f_lock);
+
+    return ret;
+}
+
 int mca_io_ompio_file_preallocate (ompi_file_t *fh,
                                    OMPI_MPI_OFFSET_TYPE diskspace)
 {
@@ -613,4 +664,3 @@ int mca_io_ompio_file_get_position_shared (ompi_file_t *fp,
 
     return ret;
 }
-
diff --git a/ompi/mca/io/ompio/io_ompio_file_set_view.c b/ompi/mca/io/ompio/io_ompio_file_set_view.c
index 5a4f8136295..3c6b31a0bc7 100644
--- a/ompi/mca/io/ompio/io_ompio_file_set_view.c
+++ b/ompi/mca/io/ompio/io_ompio_file_set_view.c
@@ -13,6 +13,8 @@
  * Copyright (c) 2015-2018 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ *  Copyright (c) 2026      Stony Brook University.  All rights reserved.
  *  $COPYRIGHT$
  *
  *  Additional copyrights may follow
@@ -48,8 +50,8 @@ static int datatype_duplicate  (ompi_datatype_t *oldtype, ompi_datatype_t **newt
         ompi_datatype_destroy (&type);
         return MPI_ERR_INTERN;
     }
-    
-    ompi_datatype_set_args( type, 0, NULL, 0, NULL, 1, &oldtype, MPI_COMBINER_DUP );
+
+    ompi_datatype_set_args( type, 0, 0, NULL, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype, MPI_COMBINER_DUP );
 
     *newtype = type;
     return OMPI_SUCCESS;
@@ -64,7 +66,11 @@ int mca_io_ompio_file_set_view (ompi_file_t *fp,
 {
     int ret=OMPI_SUCCESS;
     mca_common_ompio_data_t *data;
+    mca_common_ompio_info_phase_t previous_phase;
     ompio_file_t *fh;
+    opal_info_t *previous_info;
+    opal_info_t *staged_info;
+    int previous_bytes_per_agg;
 
     if ( (strcmp(datarep, "native") && strcmp(datarep, "NATIVE") &&
           strcmp(datarep, "external32") && strcmp(datarep, "EXTERNAL32"))) {
@@ -86,7 +92,59 @@ int mca_io_ompio_file_set_view (ompi_file_t *fp,
         
     
     OPAL_THREAD_LOCK(&fp->f_lock);
-    ret = mca_common_ompio_set_view(fh, disp, etype, filetype, datarep, info);
+    previous_info = fp->super.s_info;
+    previous_bytes_per_agg = fh->f_bytes_per_agg;
+
+    /*
+     * set_view setup consumes accepted hints while it builds the new file
+     * view.  Apply the user's info to a staged copy first: the setup code
+     * sees the requested values, but get_info will not expose them unless
+     * the whole view change succeeds.
+     */
+    staged_info = OBJ_NEW(opal_info_t);
+    if (NULL == staged_info) {
+        OPAL_THREAD_UNLOCK(&fp->f_lock);
+        return OMPI_ERR_OUT_OF_RESOURCE;
+    }
+
+    if (NULL != previous_info) {
+        ret = opal_info_dup_public(previous_info, &staged_info);
+        if (OPAL_SUCCESS != ret) {
+            OBJ_RELEASE(staged_info);
+            OPAL_THREAD_UNLOCK(&fp->f_lock);
+            return ret;
+        }
+    }
+
+    fp->super.s_info = staged_info;
+    fh->f_info = staged_info;
+
+    previous_phase = fh->f_info_phase;
+    fh->f_info_phase = MCA_COMMON_OMPIO_INFO_PHASE_SET_VIEW;
+
+    ret = mca_common_ompio_info_apply(fh, info);
+    fh->f_info_phase = previous_phase;
+
+    if (OMPI_SUCCESS == ret) {
+        ret = mca_common_ompio_set_view(fh, disp, etype, filetype, datarep, info);
+    }
+
+    if (OMPI_SUCCESS == ret) {
+        if (NULL != previous_info) {
+            OBJ_RELEASE(previous_info);
+        }
+    } else {
+        /*
+         * Restore both the public info object and the internal field updated
+         * by cb_buffer_size.  Without the field rollback, a failed set_view
+         * could leave behavior changed even though get_info was restored.
+         */
+        fp->super.s_info = previous_info;
+        fh->f_info = previous_info;
+        fh->f_bytes_per_agg = previous_bytes_per_agg;
+        OBJ_RELEASE(staged_info);
+    }
+
     OPAL_THREAD_UNLOCK(&fp->f_lock);
     return ret;
 }
@@ -112,4 +170,3 @@ int mca_io_ompio_file_get_view (struct ompi_file_t *fp,
 
     return OMPI_SUCCESS;
 }
-
diff --git a/ompi/mca/io/ompio/io_ompio_module.c b/ompi/mca/io/ompio/io_ompio_module.c
index 4b53e70d237..af4d868ed21 100644
--- a/ompi/mca/io/ompio/io_ompio_module.c
+++ b/ompi/mca/io/ompio/io_ompio_module.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2016-2019 IBM Corporation. All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -38,8 +39,8 @@ mca_io_base_module_3_0_0_t mca_io_ompio_module = {
     mca_io_ompio_file_preallocate,
     mca_io_ompio_file_get_size,
     mca_io_ompio_file_get_amode,
-    NULL,
-    NULL,
+    mca_io_ompio_file_set_info,
+    mca_io_ompio_file_get_info,
 
     mca_io_ompio_file_set_view,
     mca_io_ompio_file_get_view,
diff --git a/ompi/mca/mtl/ofi/README.md b/ompi/mca/mtl/ofi/README.md
index 0f9adc91c7f..bc353b6a082 100644
--- a/ompi/mca/mtl/ofi/README.md
+++ b/ompi/mca/mtl/ofi/README.md
@@ -187,7 +187,7 @@ approach also favours only creating as many contexts as needed.
        Number of threads = Number of communicators = Number of contexts
 
      For example, when using PSM2 provider, the number of contexts is
-     dictated by the Intel Omni-Path HFI1 driver module.
+     dictated by the Cornelis Networks Omni-Path HFI1 driver module.
 
    * OPAL layer allows for multiple threads to enter progress
      simultaneously. To enable this feature, user needs to set MCA
diff --git a/ompi/mca/osc/osc.h b/ompi/mca/osc/osc.h
index 39063ef0914..10748625db6 100644
--- a/ompi/mca/osc/osc.h
+++ b/ompi/mca/osc/osc.h
@@ -216,6 +216,15 @@ typedef int (*ompi_osc_base_module_put_fn_t)(const void *origin_addr,
                                             struct ompi_datatype_t *target_dt,
                                             struct ompi_win_t *win);
 
+typedef int (*ompi_osc_base_module_put_notify_fn_t)(const void *origin_addr,
+                                            size_t origin_count,
+                                            struct ompi_datatype_t *origin_dt,
+                                            int target,
+                                            ptrdiff_t target_disp,
+                                            size_t target_count,
+                                            struct ompi_datatype_t *target_dt,
+                                            int notify,
+                                            struct ompi_win_t *win);
 
 typedef int (*ompi_osc_base_module_get_fn_t)(void *origin_addr,
                                             size_t origin_count,
@@ -226,6 +235,36 @@ typedef int (*ompi_osc_base_module_get_fn_t)(void *origin_addr,
                                             struct ompi_datatype_t *target_dt,
                                             struct ompi_win_t *win);
 
+typedef int (*ompi_osc_base_module_get_notify_fn_t)(void *origin_addr,
+                                            size_t origin_count,
+                                            struct ompi_datatype_t *origin_dt,
+                                            int target,
+                                            ptrdiff_t target_disp,
+                                            size_t target_count,
+                                            struct ompi_datatype_t *target_dt,
+                                            int notify,
+                                            struct ompi_win_t *win);
+
+typedef int (*ompi_osc_base_module_win_get_notify_value_fn_t)(struct ompi_win_t *win,
+                                                               int notify,
+                                                               OMPI_MPI_COUNT_TYPE *value);
+                                                               
+typedef int (*ompi_osc_base_module_win_reset_notify_value_fn_t)(struct ompi_win_t *win,
+                                                                int notify,
+                                                                OMPI_MPI_COUNT_TYPE *value);
+
+typedef int (*ompi_osc_base_module_win_set_num_notify_fn_t)(struct ompi_win_t *win,
+                                                            struct opal_info_t *info,
+                                                            int num_notifications);
+
+typedef int (*ompi_osc_base_module_win_get_num_notify_fn_t)(struct ompi_win_t *win,
+                                                            int target_rank,
+                                                            int *num_notifications);
+
+typedef int (*ompi_osc_base_module_win_get_notify_bounds_fn_t)(struct ompi_win_t *win,
+                                                               int *num_sb,
+                                                               int *num_ub,
+                                                               OMPI_MPI_COUNT_TYPE *value_ub);
 
 typedef int (*ompi_osc_base_module_accumulate_fn_t)(const void *origin_addr,
                                                    size_t origin_count,
@@ -237,6 +276,17 @@ typedef int (*ompi_osc_base_module_accumulate_fn_t)(const void *origin_addr,
                                                    struct ompi_op_t *op,
                                                    struct ompi_win_t *win);
 
+typedef int (*ompi_osc_base_module_accumulate_notify_fn_t)(const void *origin_addr,
+                                                   size_t origin_count,
+                                                   struct ompi_datatype_t *origin_dt,
+                                                   int target,
+                                                   ptrdiff_t target_disp,
+                                                   size_t target_count,
+                                                   struct ompi_datatype_t *target_dt,
+                                                   struct ompi_op_t *op,
+                                                   int notify,
+                                                   struct ompi_win_t *win);
+
 typedef int (*ompi_osc_base_module_compare_and_swap_fn_t)(const void *origin_addr,
                                                           const void *compare_addr,
                                                           void *result_addr,
@@ -266,6 +316,20 @@ typedef int (*ompi_osc_base_module_get_accumulate_fn_t)(const void *origin_addr,
                                                         struct ompi_op_t *op,
                                                         struct ompi_win_t *win);
 
+typedef int (*ompi_osc_base_module_get_accumulate_notify_fn_t)(const void *origin_addr,
+                                                        size_t origin_count,
+                                                        struct ompi_datatype_t *origin_datatype,
+                                                        void *result_addr,
+                                                        size_t result_count,
+                                                        struct ompi_datatype_t *result_datatype,
+                                                        int target_rank,
+                                                        ptrdiff_t target_disp,
+                                                        size_t target_count,
+                                                        struct ompi_datatype_t *target_datatype,
+                                                        struct ompi_op_t *op,
+                                                        int notify,
+                                                        struct ompi_win_t *win);
+
 typedef int (*ompi_osc_base_module_rput_fn_t)(const void *origin_addr,
                                               size_t origin_count,
                                               struct ompi_datatype_t *origin_dt,
@@ -276,6 +340,17 @@ typedef int (*ompi_osc_base_module_rput_fn_t)(const void *origin_addr,
                                               struct ompi_win_t *win,
                                               struct ompi_request_t **request);
 
+typedef int (*ompi_osc_base_module_rput_notify_fn_t)(const void *origin_addr,
+                                              size_t origin_count,
+                                              struct ompi_datatype_t *origin_dt,
+                                              int target,
+                                              ptrdiff_t target_disp,
+                                              size_t target_count,
+                                              struct ompi_datatype_t *target_dt,
+                                              int notify,
+                                              struct ompi_win_t *win,
+                                              struct ompi_request_t **request); 
+
 typedef int (*ompi_osc_base_module_rget_fn_t)(void *origin_addr,
                                               size_t origin_count,
                                               struct ompi_datatype_t *origin_dt,
@@ -286,6 +361,16 @@ typedef int (*ompi_osc_base_module_rget_fn_t)(void *origin_addr,
                                               struct ompi_win_t *win,
                                               struct ompi_request_t **request);
 
+typedef int (*ompi_osc_base_module_rget_notify_fn_t)(void *origin_addr,
+                                              size_t origin_count,
+                                              struct ompi_datatype_t *origin_dt,
+                                              int target,
+                                              ptrdiff_t target_disp,
+                                              size_t target_count,
+                                              struct ompi_datatype_t *target_dt,
+                                              int notify,
+                                              struct ompi_win_t *win,
+                                              struct ompi_request_t **request);
 
 typedef int (*ompi_osc_base_module_raccumulate_fn_t)(const void *origin_addr,
                                                      size_t origin_count,
@@ -298,6 +383,18 @@ typedef int (*ompi_osc_base_module_raccumulate_fn_t)(const void *origin_addr,
                                                      struct ompi_win_t *win,
                                                      struct ompi_request_t **request);
 
+typedef int (*ompi_osc_base_module_raccumulate_notify_fn_t)(const void *origin_addr,
+                                                     size_t origin_count,
+                                                     struct ompi_datatype_t *origin_dt,
+                                                     int target,
+                                                     ptrdiff_t target_disp,
+                                                     size_t target_count,
+                                                     struct ompi_datatype_t *target_dt,
+                                                     struct ompi_op_t *op,
+                                                     int notify,
+                                                     struct ompi_win_t *win,
+                                                     struct ompi_request_t **request);
+
 typedef int (*ompi_osc_base_module_rget_accumulate_fn_t)(const void *origin_addr,
                                                          size_t origin_count,
                                                          struct ompi_datatype_t *origin_datatype,
@@ -312,6 +409,21 @@ typedef int (*ompi_osc_base_module_rget_accumulate_fn_t)(const void *origin_addr
                                                          struct ompi_win_t *win,
                                                          struct ompi_request_t **request);
 
+typedef int (*ompi_osc_base_module_rget_accumulate_notify_fn_t)(const void *origin_addr,
+                                                         size_t origin_count,
+                                                         struct ompi_datatype_t *origin_datatype,
+                                                         void *result_addr,
+                                                         size_t result_count,
+                                                         struct ompi_datatype_t *result_datatype,
+                                                         int target_rank,
+                                                         ptrdiff_t target_disp,
+                                                         size_t target_count,
+                                                         struct ompi_datatype_t *target_datatype,
+                                                         struct ompi_op_t *op,
+                                                         int notify,
+                                                         struct ompi_win_t *win,
+                                                         struct ompi_request_t **request);
+
 typedef int (*ompi_osc_base_module_fence_fn_t)(int mpi_assert, struct ompi_win_t *win);
 
 
@@ -407,6 +519,19 @@ struct ompi_osc_base_module_4_0_0_t {
     ompi_osc_base_module_flush_all_fn_t osc_flush_all;
     ompi_osc_base_module_flush_local_fn_t osc_flush_local;
     ompi_osc_base_module_flush_local_all_fn_t osc_flush_local_all;
+    ompi_osc_base_module_put_notify_fn_t osc_put_notify;
+    ompi_osc_base_module_get_notify_fn_t osc_get_notify;
+    ompi_osc_base_module_win_get_notify_value_fn_t osc_win_get_notify_value;
+    ompi_osc_base_module_win_reset_notify_value_fn_t osc_win_reset_notify_value;
+    ompi_osc_base_module_win_set_num_notify_fn_t osc_win_set_num_notify;
+    ompi_osc_base_module_win_get_num_notify_fn_t osc_win_get_num_notify;
+    ompi_osc_base_module_win_get_notify_bounds_fn_t osc_win_get_notify_bounds;
+    ompi_osc_base_module_rput_notify_fn_t osc_rput_notify;
+    ompi_osc_base_module_rget_notify_fn_t osc_rget_notify;
+    ompi_osc_base_module_accumulate_notify_fn_t osc_accumulate_notify;
+    ompi_osc_base_module_get_accumulate_notify_fn_t osc_get_accumulate_notify;
+    ompi_osc_base_module_raccumulate_notify_fn_t osc_raccumulate_notify;
+    ompi_osc_base_module_rget_accumulate_notify_fn_t osc_rget_accumulate_notify;
 };
 typedef struct ompi_osc_base_module_4_0_0_t ompi_osc_base_module_4_0_0_t;
 typedef ompi_osc_base_module_4_0_0_t ompi_osc_base_module_t;
diff --git a/ompi/mca/osc/sm/osc_sm.h b/ompi/mca/osc/sm/osc_sm.h
index 363d3429a63..c4c38536246 100644
--- a/ompi/mca/osc/sm/osc_sm.h
+++ b/ompi/mca/osc/sm/osc_sm.h
@@ -23,6 +23,12 @@ typedef opal_atomic_uint64_t osc_sm_post_atomic_type_t;
 #define OSC_SM_POST_BITS 6
 #define OSC_SM_POST_MASK 0x3f
 
+/* Per-rank notification counter capacity reserved inline in the main shared
+ * segment at window creation, and the value reported as
+ * MPI_WIN_NOTIFICATION_NUM_SB -- the number of counters osc/sm supports without
+ * any further allocation. */
+#define OSC_SM_DEFAULT_NOTIFY_COUNTERS 16
+
 /* data shared across all peers */
 struct ompi_osc_sm_global_state_t {
     int use_barrier_for_fence;
@@ -47,6 +53,9 @@ struct ompi_osc_sm_node_state_t {
     opal_atomic_int32_t complete_count;
     ompi_osc_sm_lock_t lock;
     opal_atomic_lock_t accumulate_lock;
+    uint32_t notify_counter_count;
+    uint32_t notify_counter_capacity;
+    uint64_t notify_counter_offset;
 };
 typedef struct ompi_osc_sm_node_state_t ompi_osc_sm_node_state_t;
 
@@ -57,6 +66,10 @@ struct ompi_osc_sm_component_t {
     unsigned int priority;
 
     char *backing_directory;
+
+    /** Notification counters reserved per MPI process at window creation when
+     *  the window's info gives no mpi_assert_max_num_notify hint */
+    unsigned int num_notify_counters;
 };
 typedef struct ompi_osc_sm_component_t ompi_osc_sm_component_t;
 OMPI_DECLSPEC extern ompi_osc_sm_component_t mca_osc_sm_component;
@@ -80,6 +93,12 @@ struct ompi_osc_sm_module_t {
     void **bases;
     ptrdiff_t *disp_units;
 
+    opal_atomic_int64_t **notify_bases;
+    opal_shmem_ds_t notify_seg_ds;
+    void *notify_segment_base;
+    unsigned int notify_max_assert;
+
+
     ompi_group_t *start_group;
     ompi_group_t *post_group;
 
@@ -105,6 +124,9 @@ int ompi_osc_sm_detach(struct ompi_win_t *win, const void *base);
 
 int ompi_osc_sm_free(struct ompi_win_t *win);
 
+void ompi_osc_sm_refresh_notify_bases(ompi_osc_sm_module_t *module);
+
+
 int ompi_osc_sm_put(const void *origin_addr,
                           size_t origin_count,
                           struct ompi_datatype_t *origin_dt,
@@ -114,6 +136,16 @@ int ompi_osc_sm_put(const void *origin_addr,
                           struct ompi_datatype_t *target_dt,
                           struct ompi_win_t *win);
 
+ int ompi_osc_sm_put_notify(const void *origin_addr,
+                           size_t origin_count,
+                           struct ompi_datatype_t *origin_dt,
+                           int target,
+                           ptrdiff_t target_disp,
+                           size_t target_count,
+                           struct ompi_datatype_t *target_dt,
+                           int notify,
+                           struct ompi_win_t *win);
+ 
 int ompi_osc_sm_get(void *origin_addr,
                           size_t origin_count,
                           struct ompi_datatype_t *origin_dt,
@@ -123,6 +155,37 @@ int ompi_osc_sm_get(void *origin_addr,
                           struct ompi_datatype_t *target_dt,
                           struct ompi_win_t *win);
 
+int ompi_osc_sm_get_notify(void *origin_addr,
+                          size_t origin_count,
+                          struct ompi_datatype_t *origin_dt,
+                          int target,
+                          ptrdiff_t target_disp,
+                          size_t target_count,
+                          struct ompi_datatype_t *target_dt,
+                          int notify,
+                          struct ompi_win_t *win);
+
+int ompi_osc_sm_win_get_notify_value(struct ompi_win_t *win,
+                                     int notify,
+                                     OMPI_MPI_COUNT_TYPE *value);
+                                     
+int ompi_osc_sm_win_reset_notify_value(struct ompi_win_t *win,
+                                       int notify,
+                                       OMPI_MPI_COUNT_TYPE *value);
+
+int ompi_osc_sm_win_set_num_notify(struct ompi_win_t *win,
+                                   struct opal_info_t *info,
+                                   int num_notifications);
+
+int ompi_osc_sm_win_get_num_notify(struct ompi_win_t *win,
+                                   int target_rank,
+                                   int *num_notifications);
+
+int ompi_osc_sm_win_get_notify_bounds(struct ompi_win_t *win,
+                                      int *num_sb,
+                                      int *num_ub,
+                                      OMPI_MPI_COUNT_TYPE *value_ub);
+
 int ompi_osc_sm_accumulate(const void *origin_addr,
                                  size_t origin_count,
                                  struct ompi_datatype_t *origin_dt,
@@ -133,6 +196,17 @@ int ompi_osc_sm_accumulate(const void *origin_addr,
                                  struct ompi_op_t *op,
                                  struct ompi_win_t *win);
 
+int ompi_osc_sm_accumulate_notify(const void *origin_addr,
+                                  size_t origin_count,
+                                  struct ompi_datatype_t *origin_dt,
+                                  int target,
+                                  ptrdiff_t target_disp,
+                                  size_t target_count,
+                                  struct ompi_datatype_t *target_dt,
+                                  struct ompi_op_t *op,
+                                  int notify,
+                                  struct ompi_win_t *win);
+
 int ompi_osc_sm_compare_and_swap(const void *origin_addr,
                                        const void *compare_addr,
                                        void *result_addr,
@@ -162,6 +236,20 @@ int ompi_osc_sm_get_accumulate(const void *origin_addr,
                                      struct ompi_op_t *op,
                                      struct ompi_win_t *win);
 
+int ompi_osc_sm_get_accumulate_notify(const void *origin_addr,
+                                      size_t origin_count,
+                                      struct ompi_datatype_t *origin_datatype,
+                                      void *result_addr,
+                                      size_t result_count,
+                                      struct ompi_datatype_t *result_datatype,
+                                      int target_rank,
+                                      MPI_Aint target_disp,
+                                      size_t target_count,
+                                      struct ompi_datatype_t *target_datatype,
+                                      struct ompi_op_t *op,
+                                      int notify,
+                                      struct ompi_win_t *win);
+
 int ompi_osc_sm_rput(const void *origin_addr,
                            size_t origin_count,
                            struct ompi_datatype_t *origin_dt,
@@ -172,6 +260,17 @@ int ompi_osc_sm_rput(const void *origin_addr,
                            struct ompi_win_t *win,
                            struct ompi_request_t **request);
 
+int ompi_osc_sm_rput_notify(const void *origin_addr,
+                          size_t origin_count,
+                          struct ompi_datatype_t *origin_dt,
+                          int target,
+                          ptrdiff_t target_disp,
+                          size_t target_count,
+                          struct ompi_datatype_t *target_dt,
+                          int notify,
+                          struct ompi_win_t *win,
+                          struct ompi_request_t **request);
+
 int ompi_osc_sm_rget(void *origin_addr,
                            size_t origin_count,
                            struct ompi_datatype_t *origin_dt,
@@ -182,6 +281,17 @@ int ompi_osc_sm_rget(void *origin_addr,
                            struct ompi_win_t *win,
                            struct ompi_request_t **request);
 
+int ompi_osc_sm_rget_notify(void *origin_addr,
+                          size_t origin_count,
+                          struct ompi_datatype_t *origin_dt,
+                          int target,
+                          ptrdiff_t target_disp,
+                          size_t target_count,
+                          struct ompi_datatype_t *target_dt,
+                          int notify,
+                          struct ompi_win_t *win,
+                          struct ompi_request_t **request);
+
 int ompi_osc_sm_raccumulate(const void *origin_addr,
                                   size_t origin_count,
                                   struct ompi_datatype_t *origin_dt,
@@ -193,6 +303,18 @@ int ompi_osc_sm_raccumulate(const void *origin_addr,
                                   struct ompi_win_t *win,
                                   struct ompi_request_t **request);
 
+int ompi_osc_sm_raccumulate_notify(const void *origin_addr,
+                                   size_t origin_count,
+                                   struct ompi_datatype_t *origin_dt,
+                                   int target,
+                                   ptrdiff_t target_disp,
+                                   size_t target_count,
+                                   struct ompi_datatype_t *target_dt,
+                                   struct ompi_op_t *op,
+                                   int notify,
+                                   struct ompi_win_t *win,
+                                   struct ompi_request_t **request);
+
 int ompi_osc_sm_rget_accumulate(const void *origin_addr,
                                       size_t origin_count,
                                       struct ompi_datatype_t *origin_datatype,
@@ -207,6 +329,21 @@ int ompi_osc_sm_rget_accumulate(const void *origin_addr,
                                       struct ompi_win_t *win,
                                       struct ompi_request_t **request);
 
+int ompi_osc_sm_rget_accumulate_notify(const void *origin_addr,
+                                       size_t origin_count,
+                                       struct ompi_datatype_t *origin_datatype,
+                                       void *result_addr,
+                                       size_t result_count,
+                                       struct ompi_datatype_t *result_datatype,
+                                       int target_rank,
+                                       MPI_Aint target_disp,
+                                       size_t target_count,
+                                       struct ompi_datatype_t *target_datatype,
+                                       struct ompi_op_t *op,
+                                       int notify,
+                                       struct ompi_win_t *win,
+                                       struct ompi_request_t **request);
+
 int ompi_osc_sm_fence(int mpi_assert, struct ompi_win_t *win);
 
 int ompi_osc_sm_start(struct ompi_group_t *group,
diff --git a/ompi/mca/osc/sm/osc_sm_comm.c b/ompi/mca/osc/sm/osc_sm_comm.c
index bbd5873bf96..9838d4d94a8 100644
--- a/ompi/mca/osc/sm/osc_sm_comm.c
+++ b/ompi/mca/osc/sm/osc_sm_comm.c
@@ -17,9 +17,347 @@
 #include "ompi/mca/osc/osc.h"
 #include "ompi/mca/osc/base/base.h"
 #include "ompi/mca/osc/base/osc_base_obj_convert.h"
+#include "ompi/communicator/communicator.h"
+#include "opal/align.h"
+#include "opal/util/printf.h"
+#include "opal/util/sys_limits.h"
+
+#include <limits.h>
+#include <stdint.h>
 
 #include "osc_sm.h"
 
+static inline opal_atomic_int64_t *
+osc_sm_target_notify_base(ompi_osc_sm_module_t *module, int target)
+{
+    return module->notify_bases[target];
+}
+
+static inline int
+osc_sm_check_notify_idx(ompi_osc_sm_module_t *module, int target, int notify)
+{
+    if (notify < 0 || (uint32_t) notify >= module->node_states[target].notify_counter_count) {
+        return MPI_ERR_RMA_NOTIFICATION;
+    }
+
+    return OMPI_SUCCESS;
+}
+
+static inline void
+osc_sm_notify_accumulate_done(ompi_osc_sm_module_t *module, int target, int notify)
+{
+    opal_atomic_mb();
+    opal_atomic_add(&osc_sm_target_notify_base(module, target)[notify], 1);
+}
+
+int
+ompi_osc_sm_win_get_notify_value(struct ompi_win_t *win,
+                                 int notify,
+                                 OMPI_MPI_COUNT_TYPE *value)
+{
+    ompi_osc_sm_module_t *module = (ompi_osc_sm_module_t *) win->w_osc_module;
+    int rank = ompi_comm_rank(module->comm);
+    int ret;
+
+    ret = osc_sm_check_notify_idx(module, rank, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    *value = (OMPI_MPI_COUNT_TYPE) osc_sm_target_notify_base(module, rank)[notify];
+    opal_atomic_rmb();
+
+    return OMPI_SUCCESS;
+}
+
+int
+ompi_osc_sm_win_reset_notify_value(struct ompi_win_t *win,
+                                   int notify,
+                                   OMPI_MPI_COUNT_TYPE *value)
+{
+    ompi_osc_sm_module_t *module = (ompi_osc_sm_module_t *) win->w_osc_module;
+    int rank = ompi_comm_rank(module->comm);
+    int ret;
+
+    ret = osc_sm_check_notify_idx(module, rank, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Atomically swap the counter to 0 and return the previous value. */
+    *value = (OMPI_MPI_COUNT_TYPE) opal_atomic_swap_64(
+                 &osc_sm_target_notify_base(module, rank)[notify], 0);
+    opal_atomic_rmb();
+
+    return OMPI_SUCCESS;
+}
+
+/* Move every rank's notification counters into a newly created shared segment
+ * sized for the capacities in new_caps.  Collective over the window's
+ * communicator; every MPI process must call it with an identical new_caps.
+ */
+static int
+osc_sm_grow_notify_counters(ompi_osc_sm_module_t *module, const unsigned long *new_caps,
+                            unsigned long new_count)
+{
+    int comm_size = ompi_comm_size(module->comm);
+    int rank = ompi_comm_rank(module->comm);
+    opal_shmem_ds_t new_seg_ds;
+    opal_shmem_ds_t old_seg_ds = module->notify_seg_ds;
+    void *old_segment_base = module->notify_segment_base;
+    void *new_base;
+    unsigned long total_counters = 0;
+    size_t seg_size;
+    char *data_file;
+    int ret, i, status;
+
+    for (i = 0 ; i < comm_size ; ++i) {
+        total_counters += new_caps[i];
+    }
+    seg_size = total_counters * sizeof(int64_t);
+    seg_size += OPAL_ALIGN_PAD_AMOUNT(seg_size, opal_getpagesize());
+
+    memset(&new_seg_ds, 0, sizeof(new_seg_ds));
+
+    if (0 == rank) {
+        ret = opal_asprintf(&data_file, "%s" OPAL_PATH_SEP "osc_sm_notify.%s.%x.%d.%s.%lu",
+                            mca_osc_sm_component.backing_directory, ompi_process_info.nodename,
+                            OMPI_PROC_MY_NAME->jobid, (int) OMPI_PROC_MY_NAME->vpid,
+                            ompi_comm_print_cid(module->comm), total_counters);
+        if (ret > 0) {
+            (void) opal_shmem_segment_create(&new_seg_ds, data_file, seg_size);
+            free(data_file);
+        }
+    }
+
+    ret = module->comm->c_coll->coll_bcast(&new_seg_ds, sizeof(new_seg_ds), MPI_BYTE, 0,
+                                           module->comm,
+                                           module->comm->c_coll->coll_bcast_module);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    if ('\0' == new_seg_ds.seg_name[0]) {
+        return MPI_ERR_NO_MEM;
+    }
+
+    new_base = opal_shmem_segment_attach(&new_seg_ds);
+
+    /* Attach can fail at some MPI processes and not others.  Agree on the
+     * outcome before touching any shared state */
+    status = (NULL == new_base) ? 1 : 0;
+    ret = module->comm->c_coll->coll_allreduce(MPI_IN_PLACE, &status, 1, MPI_INT, MPI_MAX,
+                                               module->comm,
+                                               module->comm->c_coll->coll_allreduce_module);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    if (0 != status) {
+        if (NULL != new_base) {
+            opal_shmem_segment_detach(&new_seg_ds);
+        }
+        return MPI_ERR_NO_MEM;
+    }
+
+    module->notify_segment_base = new_base;
+    module->notify_seg_ds = new_seg_ds;
+
+    /* Republish the layout.  Every MPI process computes the same offsets from
+     * the same new_caps, so these stores are identical everywhere; node_states
+     * lives in the main segment, which does not move. */
+    total_counters = 0;
+    for (i = 0 ; i < comm_size ; ++i) {
+        module->node_states[i].notify_counter_capacity = (uint32_t) new_caps[i];
+        module->node_states[i].notify_counter_offset = total_counters * sizeof(int64_t);
+        total_counters += new_caps[i];
+    }
+
+    ompi_osc_sm_refresh_notify_bases(module);
+
+    memset((void *) module->notify_bases[rank], 0,
+           module->node_states[rank].notify_counter_capacity * sizeof(int64_t));
+
+    module->node_states[rank].notify_counter_count = (uint32_t) new_count;
+    opal_atomic_wmb();
+
+    /* Everyone has opened the new segment and published their layout.  Both
+     * facts are needed before we continue: the unlink below removes the name
+     * that the attach above resolves, and an origin returning from this call
+     * may immediately validate a notification index against our count. */
+    ret = module->comm->c_coll->coll_barrier(module->comm,
+                                             module->comm->c_coll->coll_barrier_module);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    if (0 == rank) {
+        opal_shmem_unlink(&module->notify_seg_ds);
+    }
+
+    /* Dropping the old mapping is purely local -- munmap in one MPI process
+     * does not disturb any other process's view -- so it needs no
+     * synchronization of its own.  On the first growth there is nothing to
+     * drop: the counters were inline in the main segment, which stays mapped
+     * for the lifetime of the window. */
+    if (NULL != old_segment_base) {
+        opal_shmem_segment_detach(&old_seg_ds);
+    }
+
+    return OMPI_SUCCESS;
+}
+
+int
+ompi_osc_sm_win_set_num_notify(struct ompi_win_t *win,
+                               struct opal_info_t *info,
+                               int num_notifications)
+{
+    ompi_osc_sm_module_t *module = (ompi_osc_sm_module_t *) win->w_osc_module;
+    int comm_size = ompi_comm_size(module->comm);
+    int rank = ompi_comm_rank(module->comm);
+    unsigned long requested = (unsigned long) num_notifications;
+    unsigned long *new_caps;
+    bool grow = false, bad;
+    int ret, i;
+
+    /* "mpi_assert_same_num_notifications" would let us skip the allgather below
+     * and derive the layout from our own num_notifications.  Not taken up yet;
+     * the allgather is one collective on a procedure that is already
+     * synchronizing and collective. */
+    (void) info;
+
+    /* num_notifications is a local argument -- MPI-5.1 12.6.1 allows it to
+     * differ between MPI processes -- but this is a synchronizing collective.
+     * A rank that rejected its own value and returned here would leave every
+     * other rank blocked in the allgather below, turning an erroneous argument
+     * into a hang.  So the validity rides through the collective as a sentinel
+     * and all ranks fail together.  A multi-process window defers the decision;
+     * a single-process one has nobody to agree with and can answer now. */
+    bad = (num_notifications < 0)
+          || (0 != module->notify_max_assert &&
+              requested > (unsigned long) module->notify_max_assert);
+
+    if (bad && 1 == comm_size) {
+        return MPI_ERR_ARG;
+    }
+
+    if (bad) {
+        /* Leave our counters alone: the call is going to fail on every rank, so
+         * the window must come out of it unchanged rather than half-reset. */
+        requested = ULONG_MAX;
+        goto agree;
+    }
+
+    memset((void *) module->notify_bases[rank], 0,
+           module->node_states[rank].notify_counter_capacity * sizeof(int64_t));
+    module->node_states[rank].notify_counter_count =
+        (requested > module->node_states[rank].notify_counter_capacity)
+            ? module->node_states[rank].notify_counter_capacity
+            : (uint32_t) requested;
+    opal_atomic_wmb();
+
+    if (1 == comm_size) {
+        /* No shared segment for a single-process window; the counters are a
+         * plain allocation, so growing them is a plain reallocation and none of
+         * the collective machinery below applies. */
+        if (requested > module->node_states[0].notify_counter_capacity) {
+            void *grown = calloc(requested, sizeof(int64_t));
+            if (NULL == grown) {
+                return MPI_ERR_NO_MEM;
+            }
+            free((void *) module->notify_bases[0]);
+            module->notify_bases[0] = (opal_atomic_int64_t *) grown;
+            module->node_states[0].notify_counter_capacity = (uint32_t) requested;
+            module->node_states[0].notify_counter_count = (uint32_t) requested;
+        }
+        return OMPI_SUCCESS;
+    }
+
+agree:
+    new_caps = malloc(sizeof(*new_caps) * comm_size);
+    if (NULL == new_caps) {
+        return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
+    }
+
+    ret = module->comm->c_coll->coll_allgather(&requested, 1, MPI_UNSIGNED_LONG,
+                                               new_caps, 1, MPI_UNSIGNED_LONG,
+                                               module->comm,
+                                               module->comm->c_coll->coll_allgather_module);
+    if (OMPI_SUCCESS != ret) {
+        free(new_caps);
+        return ret;
+    }
+
+    for (i = 0 ; i < comm_size ; ++i) {
+        if (ULONG_MAX == new_caps[i]) {
+            /* Some rank supplied an invalid count.  Every rank sees the same
+             * gathered array, so they all report the same error and none of
+             * them reconfigures. */
+            free(new_caps);
+            return MPI_ERR_ARG;
+        }
+    }
+
+    for (i = 0 ; i < comm_size ; ++i) {
+        if (new_caps[i] > module->node_states[i].notify_counter_capacity) {
+            grow = true;
+        } else {
+            /* Never shrink: a rank that lowered its count keeps the space it
+             * already has, so that only genuine growth costs a reallocation. */
+            new_caps[i] = module->node_states[i].notify_counter_capacity;
+        }
+    }
+
+    if (grow) {
+        ret = osc_sm_grow_notify_counters(module, new_caps, requested);
+        free(new_caps);
+        return ret;
+    }
+
+    free(new_caps);
+
+    return OMPI_SUCCESS;
+}
+
+int
+ompi_osc_sm_win_get_num_notify(struct ompi_win_t *win,
+                               int target_rank,
+                               int *num_notifications)
+{
+    ompi_osc_sm_module_t *module = (ompi_osc_sm_module_t *) win->w_osc_module;
+
+    if (target_rank < 0 || target_rank >= ompi_comm_size(module->comm)) {
+        return MPI_ERR_RANK;
+    }
+
+    *num_notifications = (int) module->node_states[target_rank].notify_counter_count;
+
+    return OMPI_SUCCESS;
+}
+
+int
+ompi_osc_sm_win_get_notify_bounds(struct ompi_win_t *win,
+                                  int *num_sb,
+                                  int *num_ub,
+                                  OMPI_MPI_COUNT_TYPE *value_ub)
+{
+    ompi_osc_sm_module_t *module = (ompi_osc_sm_module_t *) win->w_osc_module;
+
+    if (0 != module->notify_max_assert) {
+        *num_sb = (int) module->notify_max_assert;
+        *num_ub = (int) module->notify_max_assert;
+    } else {
+        *num_sb = (int) mca_osc_sm_component.num_notify_counters;
+        *num_ub = INT_MAX;
+    }
+
+    /* Counters are int64_t and only ever incremented by one per notified
+     * operation, so the representable maximum is the real bound. */
+    *value_ub = (OMPI_MPI_COUNT_TYPE) INT64_MAX;
+
+    return OMPI_SUCCESS;
+}
+
 int
 ompi_osc_sm_rput(const void *origin_addr,
                  size_t origin_count,
@@ -59,6 +397,56 @@ ompi_osc_sm_rput(const void *origin_addr,
     return OMPI_SUCCESS;
 }
 
+int
+ompi_osc_sm_rput_notify(const void *origin_addr,
+                 size_t origin_count,
+                 struct ompi_datatype_t *origin_dt,
+                 int target,
+                 ptrdiff_t target_disp,
+                 size_t target_count,
+                 struct ompi_datatype_t *target_dt,
+                 int notify,
+                 struct ompi_win_t *win,
+                 struct ompi_request_t **ompi_req)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                         "rput_notify: 0x%lx, %zu, %s, %d, %d, %zu, %s, %d, 0x%lx",
+                         (unsigned long) origin_addr, origin_count,
+                         origin_dt->name, target, (int) target_disp,
+                         target_count, target_dt->name,
+                         notify,
+                         (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    ret = ompi_datatype_sndrcv((void *)origin_addr, origin_count, origin_dt,
+                               remote_address, target_count, target_dt);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Release ordering: the data must be visible at the target before the
+     * notification is */
+    opal_atomic_wmb();
+    opal_atomic_add(&osc_sm_target_notify_base(module, target)[notify], 1);
+
+    /* the only valid field of RMA request status is the MPI_ERROR field.
+     * ompi_request_empty has status MPI_SUCCESS and indicates the request is
+     * complete. */
+    *ompi_req = &ompi_request_empty;
+
+    return OMPI_SUCCESS;
+}
 
 int
 ompi_osc_sm_rget(void *origin_addr,
@@ -99,6 +487,54 @@ ompi_osc_sm_rget(void *origin_addr,
     return OMPI_SUCCESS;
 }
 
+int
+ompi_osc_sm_rget_notify(void *origin_addr,
+                 size_t origin_count,
+                 struct ompi_datatype_t *origin_dt,
+                 int target,
+                 ptrdiff_t target_disp,
+                 size_t target_count,
+                 struct ompi_datatype_t *target_dt,
+                 int notify,
+                 struct ompi_win_t *win,
+                 struct ompi_request_t **ompi_req)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                         "rget_notify: 0x%lx, %zu, %s, %d, %d, %zu, %s, %d, 0x%lx",
+                         (unsigned long) origin_addr, origin_count,
+                         origin_dt->name, target, (int) target_disp,
+                         target_count, target_dt->name,
+                         notify,
+                         (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    ret = ompi_datatype_sndrcv(remote_address, target_count, target_dt,
+                               origin_addr, origin_count, origin_dt);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    opal_atomic_mb();
+    opal_atomic_add(&osc_sm_target_notify_base(module, target)[notify], 1);
+
+    /* the only valid field of RMA request status is the MPI_ERROR field.
+     * ompi_request_empty has status MPI_SUCCESS and indicates the request is
+     * complete. */
+    *ompi_req = &ompi_request_empty;
+
+    return OMPI_SUCCESS;
+}
 
 int
 ompi_osc_sm_raccumulate(const void *origin_addr,
@@ -147,6 +583,67 @@ ompi_osc_sm_raccumulate(const void *origin_addr,
 }
 
 
+int
+ompi_osc_sm_raccumulate_notify(const void *origin_addr,
+                               size_t origin_count,
+                               struct ompi_datatype_t *origin_dt,
+                               int target,
+                               ptrdiff_t target_disp,
+                               size_t target_count,
+                               struct ompi_datatype_t *target_dt,
+                               struct ompi_op_t *op,
+                               int notify,
+                               struct ompi_win_t *win,
+                               struct ompi_request_t **ompi_req)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                         "raccumulate_notify: 0x%lx, %zu, %s, %d, %d, %zu, %s, %s, %d, 0x%lx",
+                         (unsigned long) origin_addr, origin_count,
+                         origin_dt->name, target, (int) target_disp,
+                         target_count, target_dt->name,
+                         op->o_name, notify,
+                         (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    opal_atomic_lock(&module->node_states[target].accumulate_lock);
+    if (op == &ompi_mpi_op_replace.op) {
+        ret = ompi_datatype_sndrcv((void *)origin_addr, origin_count, origin_dt,
+                                    remote_address, target_count, target_dt);
+    } else {
+        ret = ompi_osc_base_sndrcv_op(origin_addr, origin_count, origin_dt,
+                                      remote_address, target_count, target_dt,
+                                      op);
+    }
+    opal_atomic_unlock(&module->node_states[target].accumulate_lock);
+
+    /* Only notify once the accumulate actually happened -- a counter bumped for
+     * an operation that failed would tell the target that data it never
+     * received is ready. */
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    osc_sm_notify_accumulate_done(module, target, notify);
+
+    /* the only valid field of RMA request status is the MPI_ERROR field.
+     * ompi_request_empty has status MPI_SUCCESS and indicates the request is
+     * complete. */
+    *ompi_req = &ompi_request_empty;
+
+    return ret;
+}
+
 
 int
 ompi_osc_sm_rget_accumulate(const void *origin_addr,
@@ -205,6 +702,78 @@ ompi_osc_sm_rget_accumulate(const void *origin_addr,
 }
 
 
+int
+ompi_osc_sm_rget_accumulate_notify(const void *origin_addr,
+                                   size_t origin_count,
+                                   struct ompi_datatype_t *origin_dt,
+                                   void *result_addr,
+                                   size_t result_count,
+                                   struct ompi_datatype_t *result_dt,
+                                   int target,
+                                   MPI_Aint target_disp,
+                                   size_t target_count,
+                                   struct ompi_datatype_t *target_dt,
+                                   struct ompi_op_t *op,
+                                   int notify,
+                                   struct ompi_win_t *win,
+                                   struct ompi_request_t **ompi_req)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                         "rget_accumulate_notify: 0x%lx, %zu, %s, %d, %d, %zu, %s, %s, %d, 0x%lx",
+                         (unsigned long) origin_addr, origin_count,
+                         origin_dt->name, target, (int) target_disp,
+                         target_count, target_dt->name,
+                         op->o_name, notify,
+                         (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    opal_atomic_lock(&module->node_states[target].accumulate_lock);
+
+    ret = ompi_datatype_sndrcv(remote_address, target_count, target_dt,
+                               result_addr, result_count, result_dt);
+    if (OMPI_SUCCESS != ret || op == &ompi_mpi_op_no_op.op) goto done;
+
+    if (op == &ompi_mpi_op_replace.op) {
+        ret = ompi_datatype_sndrcv((void *)origin_addr, origin_count, origin_dt,
+                                   remote_address, target_count, target_dt);
+    } else {
+        ret = ompi_osc_base_sndrcv_op(origin_addr, origin_count, origin_dt,
+                                      remote_address, target_count, target_dt,
+                                      op);
+    }
+
+ done:
+    opal_atomic_unlock(&module->node_states[target].accumulate_lock);
+
+    /* Only notify once the operation actually happened.  MPI_NO_OP is not a
+     * failure: the target window was still read into the result buffer, which is
+     * an access the notification is required to cover. */
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    osc_sm_notify_accumulate_done(module, target, notify);
+
+    /* the only valid field of RMA request status is the MPI_ERROR field.
+     * ompi_request_empty has status MPI_SUCCESS and indicates the request is
+     * complete. */
+    *ompi_req = &ompi_request_empty;
+
+    return ret;
+}
+
+
 int
 ompi_osc_sm_put(const void *origin_addr,
                       size_t origin_count,
@@ -236,6 +805,52 @@ ompi_osc_sm_put(const void *origin_addr,
 }
 
 
+int
+ompi_osc_sm_put_notify(const void *origin_addr,
+                size_t origin_count,
+                struct ompi_datatype_t *origin_dt,
+                int target,
+                ptrdiff_t target_disp,
+                size_t target_count,
+                struct ompi_datatype_t *target_dt,
+                int notify,
+                struct ompi_win_t *win)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                            "put_notify: 0x%lx, %zu, %s, %d, %d, %zu, %s, %d, 0x%lx",
+                            (unsigned long) origin_addr, origin_count,
+                            origin_dt->name, target, (int) target_disp,
+                            target_count, target_dt->name,
+                            notify,
+                            (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    ret = ompi_datatype_sndrcv((void *)origin_addr, origin_count, origin_dt,
+                                remote_address, target_count, target_dt);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* (MPI-5.1 section 12.3, "The notification counter will be
+     * updated at the target only after the completion of the data movement
+     * operation at the target"). */
+    opal_atomic_wmb();
+    opal_atomic_add(&osc_sm_target_notify_base(module, target)[notify], 1);
+
+    return ret;
+}
+
 int
 ompi_osc_sm_get(void *origin_addr,
                       size_t origin_count,
@@ -267,6 +882,50 @@ ompi_osc_sm_get(void *origin_addr,
 }
 
 
+int
+ompi_osc_sm_get_notify(void *origin_addr,
+                size_t origin_count,
+                struct ompi_datatype_t *origin_dt,
+                int target,
+                ptrdiff_t target_disp,
+                size_t target_count,
+                struct ompi_datatype_t *target_dt,
+                int notify,
+                struct ompi_win_t *win)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                         "get: 0x%lx, %zu, %s, %d, %d, %zu, %s, 0x%lx",
+                         (unsigned long) origin_addr, origin_count,
+                         origin_dt->name, target, (int) target_disp,
+                         target_count, target_dt->name,
+                         (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    ret = ompi_datatype_sndrcv(remote_address, target_count, target_dt,
+                               origin_addr, origin_count, origin_dt);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Full barrier, not opal_atomic_rmb(): see ompi_osc_sm_rget_notify(). */
+    opal_atomic_mb();
+    opal_atomic_add(&osc_sm_target_notify_base(module, target)[notify], 1);
+
+    return ret;
+}
+
+
 int
 ompi_osc_sm_accumulate(const void *origin_addr,
                        size_t origin_count,
@@ -308,6 +967,62 @@ ompi_osc_sm_accumulate(const void *origin_addr,
 }
 
 
+int
+ompi_osc_sm_accumulate_notify(const void *origin_addr,
+                              size_t origin_count,
+                              struct ompi_datatype_t *origin_dt,
+                              int target,
+                              ptrdiff_t target_disp,
+                              size_t target_count,
+                              struct ompi_datatype_t *target_dt,
+                              struct ompi_op_t *op,
+                              int notify,
+                              struct ompi_win_t *win)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                         "accumulate_notify: 0x%lx, %zu, %s, %d, %d, %zu, %s, %s, %d, 0x%lx",
+                         (unsigned long) origin_addr, origin_count,
+                         origin_dt->name, target, (int) target_disp,
+                         target_count, target_dt->name,
+                         op->o_name, notify,
+                         (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    opal_atomic_lock(&module->node_states[target].accumulate_lock);
+    if (op == &ompi_mpi_op_replace.op) {
+        ret = ompi_datatype_sndrcv((void *)origin_addr, origin_count, origin_dt,
+                                    remote_address, target_count, target_dt);
+    } else {
+        ret = ompi_osc_base_sndrcv_op(origin_addr, origin_count, origin_dt,
+                                      remote_address, target_count, target_dt,
+                                      op);
+    }
+    opal_atomic_unlock(&module->node_states[target].accumulate_lock);
+
+    /* Only notify once the accumulate actually happened -- a counter bumped for
+     * an operation that failed would tell the target that data it never
+     * received is ready. */
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    osc_sm_notify_accumulate_done(module, target, notify);
+
+    return ret;
+}
+
+
 int
 ompi_osc_sm_get_accumulate(const void *origin_addr,
                            size_t origin_count,
@@ -359,6 +1074,72 @@ ompi_osc_sm_get_accumulate(const void *origin_addr,
 }
 
 
+int
+ompi_osc_sm_get_accumulate_notify(const void *origin_addr,
+                                  size_t origin_count,
+                                  struct ompi_datatype_t *origin_dt,
+                                  void *result_addr,
+                                  size_t result_count,
+                                  struct ompi_datatype_t *result_dt,
+                                  int target,
+                                  MPI_Aint target_disp,
+                                  size_t target_count,
+                                  struct ompi_datatype_t *target_dt,
+                                  struct ompi_op_t *op,
+                                  int notify,
+                                  struct ompi_win_t *win)
+{
+    int ret;
+    ompi_osc_sm_module_t *module =
+        (ompi_osc_sm_module_t*) win->w_osc_module;
+    void *remote_address;
+
+    OPAL_OUTPUT_VERBOSE((50, ompi_osc_base_framework.framework_output,
+                         "get_accumulate_notify: 0x%lx, %zu, %s, %d, %d, %zu, %s, %s, %d, 0x%lx",
+                         (unsigned long) origin_addr, origin_count,
+                         origin_dt->name, target, (int) target_disp,
+                         target_count, target_dt->name,
+                         op->o_name, notify,
+                         (unsigned long) win));
+
+    ret = osc_sm_check_notify_idx(module, target, notify);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    remote_address = ((char*) (module->bases[target])) + module->disp_units[target] * target_disp;
+
+    opal_atomic_lock(&module->node_states[target].accumulate_lock);
+
+    ret = ompi_datatype_sndrcv(remote_address, target_count, target_dt,
+                               result_addr, result_count, result_dt);
+    if (OMPI_SUCCESS != ret || op == &ompi_mpi_op_no_op.op) goto done;
+
+    if (op == &ompi_mpi_op_replace.op) {
+        ret = ompi_datatype_sndrcv((void *)origin_addr, origin_count, origin_dt,
+                                   remote_address, target_count, target_dt);
+    } else {
+        ret = ompi_osc_base_sndrcv_op(origin_addr, origin_count, origin_dt,
+                                      remote_address, target_count, target_dt,
+                                      op);
+    }
+
+ done:
+    opal_atomic_unlock(&module->node_states[target].accumulate_lock);
+
+    /* Only notify once the operation actually happened.  MPI_NO_OP is not a
+     * failure: the target window was still read into the result buffer, which is
+     * an access the notification is required to cover. */
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    osc_sm_notify_accumulate_done(module, target, notify);
+
+    return ret;
+}
+
+
 int
 ompi_osc_sm_compare_and_swap(const void *origin_addr,
                              const void *compare_addr,
@@ -437,5 +1218,5 @@ ompi_osc_sm_fetch_and_op(const void *origin_addr,
  done:
     opal_atomic_unlock(&module->node_states[target].accumulate_lock);
 
-    return OMPI_SUCCESS;;
+    return OMPI_SUCCESS;
 }
diff --git a/ompi/mca/osc/sm/osc_sm_component.c b/ompi/mca/osc/sm/osc_sm_component.c
index ad2b3cae25a..055fb460ee7 100644
--- a/ompi/mca/osc/sm/osc_sm_component.c
+++ b/ompi/mca/osc/sm/osc_sm_component.c
@@ -31,7 +31,9 @@
 #include "ompi/request/request.h"
 #include "opal/util/sys_limits.h"
 #include "opal/align.h"
+#include "opal/util/info.h"
 #include "opal/util/printf.h"
+#include "opal/class/opal_cstring.h"
 #include "opal/mca/mpool/base/base.h"
 
 #include "osc_sm.h"
@@ -79,16 +81,29 @@ ompi_osc_sm_module_t ompi_osc_sm_module_template = {
         .osc_free = ompi_osc_sm_free,
 
         .osc_put = ompi_osc_sm_put,
+        .osc_put_notify = ompi_osc_sm_put_notify,
         .osc_get = ompi_osc_sm_get,
+        .osc_get_notify = ompi_osc_sm_get_notify,
+        .osc_win_get_notify_value = ompi_osc_sm_win_get_notify_value,
+        .osc_win_reset_notify_value = ompi_osc_sm_win_reset_notify_value,
+        .osc_win_set_num_notify = ompi_osc_sm_win_set_num_notify,
+        .osc_win_get_num_notify = ompi_osc_sm_win_get_num_notify,
+        .osc_win_get_notify_bounds = ompi_osc_sm_win_get_notify_bounds,
         .osc_accumulate = ompi_osc_sm_accumulate,
+        .osc_accumulate_notify = ompi_osc_sm_accumulate_notify,
         .osc_compare_and_swap = ompi_osc_sm_compare_and_swap,
         .osc_fetch_and_op = ompi_osc_sm_fetch_and_op,
         .osc_get_accumulate = ompi_osc_sm_get_accumulate,
+        .osc_get_accumulate_notify = ompi_osc_sm_get_accumulate_notify,
 
         .osc_rput = ompi_osc_sm_rput,
+        .osc_rput_notify = ompi_osc_sm_rput_notify,
         .osc_rget = ompi_osc_sm_rget,
+        .osc_rget_notify = ompi_osc_sm_rget_notify,
         .osc_raccumulate = ompi_osc_sm_raccumulate,
+        .osc_raccumulate_notify = ompi_osc_sm_raccumulate_notify,
         .osc_rget_accumulate = ompi_osc_sm_rget_accumulate,
+        .osc_rget_accumulate_notify = ompi_osc_sm_rget_accumulate_notify,
 
         .osc_fence = ompi_osc_sm_fence,
 
@@ -138,9 +153,83 @@ static int component_register (void)
                                           &mca_osc_sm_component.priority);
     free(description_str);
 
+    mca_osc_sm_component.num_notify_counters = OSC_SM_DEFAULT_NOTIFY_COUNTERS;
+    opal_asprintf(&description_str,
+                  "Number of RMA notification counters reserved per MPI process "
+                  "in the shared memory segment of each window.  Windows whose "
+                  "info gives an mpi_assert_max_num_notify value use that "
+                  "instead.  MPI_Win_set_num_notify may exceed this value, at "
+                  "the cost of allocating a new shared segment (default: %u)",
+                  mca_osc_sm_component.num_notify_counters);
+    (void) mca_base_component_var_register(&mca_osc_sm_component.super.osc_version,
+                                           "num_notify_counters", description_str,
+                                           MCA_BASE_VAR_TYPE_UNSIGNED_INT, NULL, 0, 0,
+                                           OPAL_INFO_LVL_3, MCA_BASE_VAR_SCOPE_GROUP,
+                                           &mca_osc_sm_component.num_notify_counters);
+    free(description_str);
+
     return OPAL_SUCCESS;
 }
 
+
+/* Read the mpi_assert_max_num_notify info key (MPI-5.1 section 12.2). */
+static int osc_sm_reserved_notify_counters(opal_info_t *info, unsigned int *assert_value,
+                                           unsigned int *reserved)
+{
+    opal_cstring_t *value_string;
+    int flag = 0, value = 0;
+
+    *assert_value = 0;
+    *reserved = mca_osc_sm_component.num_notify_counters;
+
+    if (NULL == info) {
+        return OMPI_SUCCESS;
+    }
+
+    if (OMPI_SUCCESS != opal_info_get(info, "mpi_assert_max_num_notify",
+                                      &value_string, &flag) || !flag) {
+        return OMPI_SUCCESS;
+    }
+
+    if (OPAL_SUCCESS != opal_cstring_to_int(value_string, &value)) {
+        OBJ_RELEASE(value_string);
+        return MPI_ERR_INFO;
+    }
+    OBJ_RELEASE(value_string);
+
+    /* A negative value is a malformed key rather than "no assertion"; only 0
+     * carries the "assume nothing" meaning. */
+    if (value < 0) {
+        return MPI_ERR_INFO;
+    }
+
+    if (0 != value) {
+        *assert_value = (unsigned int) value;
+        *reserved = (unsigned int) value;
+    }
+
+    return OMPI_SUCCESS;
+}
+
+
+void
+ompi_osc_sm_refresh_notify_bases(ompi_osc_sm_module_t *module)
+{
+    int comm_size = ompi_comm_size(module->comm);
+    char *base;
+    int i;
+
+    /* Once the counters have been grown they live in their own segment;
+     * before that they sit inline in the main one. */
+    base = (NULL != module->notify_segment_base) ? (char *) module->notify_segment_base
+                                                 : (char *) module->segment_base;
+
+    for (i = 0 ; i < comm_size ; ++i) {
+        module->notify_bases[i] = (opal_atomic_int64_t *)
+            (base + module->node_states[i].notify_counter_offset);
+    }
+}
+
 static int
 component_open(void)
 {
@@ -201,6 +290,7 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
     bool unlink_needed = false;
     int ret = OMPI_ERROR;
     size_t memory_alignment = OPAL_ALIGN_MIN;
+    unsigned int notify_assert = 0, notify_reserved = 0;
 
     assert(MPI_WIN_FLAVOR_SHARED == flavor || MPI_WIN_FLAVOR_ALLOCATE == flavor);
 
@@ -231,6 +321,16 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
 
     module->flavor = flavor;
 
+    /* How many notification counters to reserve per MPI process.  Read before
+     * the segment is sized, since the reservation is part of its layout. */
+    ret = osc_sm_reserved_notify_counters(info, &notify_assert, &notify_reserved);
+    if (OMPI_SUCCESS != ret) goto error;
+    module->notify_max_assert = notify_assert;
+    module->notify_segment_base = NULL;
+
+    module->notify_bases = calloc(comm_size, sizeof(module->notify_bases[0]));
+    if (NULL == module->notify_bases) return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
+
     /* create the segment */
     if (1 == comm_size) {
         module->segment_base = NULL;
@@ -251,13 +351,22 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
         module->posts = calloc (1, sizeof(module->posts[0]) + sizeof (module->posts[0][0]));
         if (NULL == module->posts) return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
         module->posts[0] = (osc_sm_post_atomic_type_t *) (module->posts + 1);
+
+        /* Notification counters for the single process case. */
+        module->notify_bases[0] = calloc(notify_reserved, sizeof(int64_t));
+        if (NULL == module->notify_bases[0]) return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
+        module->node_states[0].notify_counter_capacity = notify_reserved;
+        module->node_states[0].notify_counter_count = notify_reserved;
+        module->node_states[0].notify_counter_offset = 0;
     } else {
-        unsigned long total, *rbuf;
+        unsigned long total, total_counters, gather_values[2], *rbuf;
         int i, flag;
         size_t pagesize;
         size_t state_size;
         size_t posts_size, post_size = (comm_size + OSC_SM_POST_MASK) / (OSC_SM_POST_MASK + 1);
+        size_t notify_counters_size;
         size_t data_base_size;
+        opal_atomic_int64_t *notify_counters_base;
 
         opal_output_verbose(MCA_BASE_VERBOSE_DEBUG, ompi_osc_base_framework.framework_output,
                             "allocating shared memory region of size %ld\n", (long) size);
@@ -265,7 +374,7 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
         /* get the pagesize */
         pagesize = opal_getpagesize();
 
-        rbuf = malloc(sizeof(unsigned long) * comm_size);
+        rbuf = malloc(sizeof(unsigned long) * comm_size * 2 );
         if (NULL == rbuf) return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
 
         /* Note that the alloc_shared_noncontig info key only has
@@ -289,9 +398,10 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
                                 "allocating window using contiguous strategy");
         }
 
-        total = size;
-        ret = module->comm->c_coll->coll_allgather(&total, 1, MPI_UNSIGNED_LONG,
-                                                  rbuf, 1, MPI_UNSIGNED_LONG,
+        gather_values[0] = size;
+        gather_values[1] = notify_reserved;
+        ret = module->comm->c_coll->coll_allgather(gather_values, 2, MPI_UNSIGNED_LONG,
+                                                  rbuf, 2, MPI_UNSIGNED_LONG,
                                                   module->comm,
                                                   module->comm->c_coll->coll_allgather_module);
         if (OMPI_SUCCESS != ret) {
@@ -300,8 +410,10 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
         }
 
         total = 0;
+        total_counters = 0;
         for (i = 0 ; i < comm_size ; ++i) {
-            total += rbuf[i];
+            total += rbuf[2 * i];
+            total_counters += rbuf[2 * i + 1];
             if (module->noncontig) {
                 total += OPAL_ALIGN_PAD_AMOUNT(total, pagesize);
             }
@@ -312,7 +424,9 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
         state_size += OPAL_ALIGN_PAD_AMOUNT(state_size, 64);
         posts_size = comm_size * post_size * sizeof (module->posts[0][0]);
         posts_size += OPAL_ALIGN_PAD_AMOUNT(posts_size, 64);
-        data_base_size = state_size + posts_size;
+        notify_counters_size = total_counters * sizeof(uint64_t);
+        notify_counters_size += OPAL_ALIGN_PAD_AMOUNT(notify_counters_size, 64);
+        data_base_size = state_size + posts_size + notify_counters_size;
         data_base_size += OPAL_ALIGN_PAD_AMOUNT(data_base_size, pagesize);
         if (0 == ompi_comm_rank (module->comm)) {
             char *data_file;
@@ -373,15 +487,26 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
         module->global_state = (ompi_osc_sm_global_state_t *) (module->posts[0] + comm_size * post_size);
         module->node_states = (ompi_osc_sm_node_state_t *) (module->global_state + 1);
 
-        for (i = 0, total = data_base_size ; i < comm_size ; ++i) {
+        /* set up notify counters in shared memory after node_states */
+        notify_counters_base = (opal_atomic_int64_t *) ((char *)(module->node_states + comm_size) +
+                                   OPAL_ALIGN_PAD_AMOUNT((uintptr_t)(module->node_states + comm_size), 64));
+
+        for (i = 0, total = data_base_size, total_counters = 0 ; i < comm_size ; ++i) {
             if (i > 0) {
                 module->posts[i] = module->posts[i - 1] + post_size;
             }
 
-            module->sizes[i] = rbuf[i];
+            module->node_states[i].notify_counter_capacity = (uint32_t) rbuf[2 * i + 1];
+            module->node_states[i].notify_counter_count = (uint32_t) rbuf[2 * i + 1];
+            module->node_states[i].notify_counter_offset =
+                (uint64_t) ((char *) (notify_counters_base + total_counters) -
+                            (char *) module->segment_base);
+            total_counters += rbuf[2 * i + 1];
+
+            module->sizes[i] = rbuf[2 * i];
             if (module->sizes[i] || !module->noncontig) {
                 module->bases[i] = ((char *) module->segment_base) + total;
-                total += rbuf[i];
+                total += rbuf[2 * i];
                 if (module->noncontig) {
                     total += OPAL_ALIGN_PAD_AMOUNT(total, pagesize);
                 }
@@ -390,12 +515,19 @@ component_select(struct ompi_win_t *win, void **base, size_t size, ptrdiff_t dis
             }
         }
 
+        ompi_osc_sm_refresh_notify_bases(module);
+
+        /* Zero only this process's own counters. */
+        memset((void *) module->notify_bases[ompi_comm_rank(module->comm)], 0,
+               notify_reserved * sizeof(int64_t));
+
         free(rbuf);
     }
 
     /* initialize my state shared */
     module->my_node_state = &module->node_states[ompi_comm_rank(module->comm)];
-    memset (module->my_node_state, 0, sizeof(*module->my_node_state));
+    module->my_node_state->complete_count = 0;
+    memset (&module->my_node_state->lock, 0, sizeof(module->my_node_state->lock));
 
     *base = module->bases[ompi_comm_rank(module->comm)];
 
@@ -550,6 +682,10 @@ ompi_osc_sm_free(struct ompi_win_t *win)
         module->comm->c_coll->coll_barrier(module->comm,
                                           module->comm->c_coll->coll_barrier_module);
 
+        if (NULL != module->notify_segment_base) {
+            opal_shmem_segment_detach (&module->notify_seg_ds);
+        }
+
         opal_shmem_segment_detach (&module->seg_ds);
     } else {
         free(module->node_states);
@@ -558,7 +694,14 @@ ompi_osc_sm_free(struct ompi_win_t *win)
             mca_mpool_base_default_module->mpool_free(mca_mpool_base_default_module,
                                                       module->bases[0]);
         }
+        /* free the counters for the single process case */
+        /* cast away the atomic/volatile qualifier for free(), as in
+         * opal/runtime/opal_progress.c */
+        if (NULL != module->notify_bases) {
+            free((void *) module->notify_bases[0]);
+        }
     }
+    free(module->notify_bases);
     free(module->disp_units);
     free(module->outstanding_locks);
     free(module->sizes);
@@ -605,6 +748,13 @@ ompi_osc_sm_get_info(struct ompi_win_t *win, struct opal_info_t **info_used)
                       (module->noncontig) ? "true" : "false");
     }
 
+    /* Report the assertion back only when one was actually given. */
+    if (0 != module->notify_max_assert) {
+        char value_str[16];
+        snprintf(value_str, sizeof(value_str), "%u", module->notify_max_assert);
+        opal_info_set(info, "mpi_assert_max_num_notify", value_str);
+    }
+
     *info_used = info;
 
     return OMPI_SUCCESS;
diff --git a/ompi/mca/osc/ubcl/configure.m4 b/ompi/mca/osc/ubcl/configure.m4
index add1db7c94b..1677000c469 100644
--- a/ompi/mca/osc/ubcl/configure.m4
+++ b/ompi/mca/osc/ubcl/configure.m4
@@ -1,4 +1,4 @@
-# Copyright (c) 2025 Bull SAS.  All rights reserved.
+# Copyright (c) 2025-2026 Bull SAS.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -21,6 +21,12 @@ AC_DEFUN([MCA_ompi_osc_ubcl_CONFIG], [
         [osc_ubcl_happy="yes"],
         [osc_ubcl_happy="no"])
 
+    # See ompi/mca/common/ubcl/configure.m4 comment explaining why UBCL linking
+    # flags are removed only in dynamic mode
+    AS_IF([test "$compile_mode" = "dso"],
+          [osc_ubcl_LDFLAGS=""],
+          [AC_MSG_WARN([Only DSO mode of osc/ubcl is tested (see --enable-mca-dso)])])
+
     AS_IF([test "$osc_ubcl_happy" = "yes"],
         [$1],
         [$2])
diff --git a/ompi/mca/osc/ubcl/osc_ubcl.c b/ompi/mca/osc/ubcl/osc_ubcl.c
index 5e81ed1add3..5a81d0a763d 100644
--- a/ompi/mca/osc/ubcl/osc_ubcl.c
+++ b/ompi/mca/osc/ubcl/osc_ubcl.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2025-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -250,7 +250,9 @@ static int component_query(struct ompi_win_t *win, void **base, size_t size, ptr
     if (MPI_WIN_FLAVOR_ALLOCATE != flavor && MPI_WIN_FLAVOR_DYNAMIC != flavor
         && 0 < size && NULL != base && NULL != *base
         && opal_accelerator.check_addr(*base, &dev_id, &flags) > 0) {
-        mca_osc_ubcl_log(20, "GPU buffer not supported by osc/ubcl");
+        mca_osc_ubcl_warn(
+            OPAL_ERR_NOT_SUPPORTED,
+            "GPU buffer not supported by osc/ubcl: disqualifying UBCL for this window creation");
         return OPAL_ERR_NOT_SUPPORTED;
     }
 
@@ -478,8 +480,11 @@ static int win_attach(struct ompi_win_t *win, void *base, size_t size)
     wid = (ubcl_wid_t) module->wid;
 
     /* Accelerator buffer is not supported as attached buffer */
-    if (opal_accelerator.check_addr(base, &dev_id, &flags)) {
-        mca_osc_ubcl_warn(OPAL_ERR_NOT_SUPPORTED, "GPU buffer not supported by osc/ubcl");
+    if (0 < size && NULL != base && opal_accelerator.check_addr(base, &dev_id, &flags)) {
+        mca_osc_ubcl_error(
+            OPAL_ERR_NOT_SUPPORTED,
+            "GPU buffer not supported by osc/ubcl: UBCL fail to attach %zu B starting at %p", size,
+            base);
         return OPAL_ERR_NOT_SUPPORTED;
     }
 
diff --git a/ompi/mca/osc/ubcl/osc_ubcl_accumulate.c b/ompi/mca/osc/ubcl/osc_ubcl_accumulate.c
index 58756665ee1..c3082188537 100644
--- a/ompi/mca/osc/ubcl/osc_ubcl_accumulate.c
+++ b/ompi/mca/osc/ubcl/osc_ubcl_accumulate.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2025-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -18,6 +18,7 @@
  * of these functions, refer to ompi/mca/osc/osc.h.
  */
 
+#include "opal/include/opal_config.h"
 #include "ompi/mca/osc/ubcl/osc_ubcl.h"
 #include "opal/mca/common/ubcl/common_ubcl.h"
 #include "ompi/mca/osc/ubcl/osc_ubcl_info.h"
@@ -211,8 +212,11 @@ static int get_logical_ubcl_type(struct ompi_datatype_t *origin_dt,
 #if OMPI_HAVE_FORTRAN_LOGICAL8
                || MPI_LOGICAL8 == origin_dt
 #endif
+/* To ease backport to older ompi versions */
+#if defined OMPI_HAVE_FORTRAN_LOGICAL16
 #if OMPI_HAVE_FORTRAN_LOGICAL16
                || MPI_LOGICAL16 == origin_dt
+#endif
 #endif
     ) {
         ret = OMPI_ERR_NOT_IMPLEMENTED;
diff --git a/ompi/mca/osc/ubcl/osc_ubcl_get.c b/ompi/mca/osc/ubcl/osc_ubcl_get.c
index f0fb8ad7706..20824deac62 100644
--- a/ompi/mca/osc/ubcl/osc_ubcl_get.c
+++ b/ompi/mca/osc/ubcl/osc_ubcl_get.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2025-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -41,7 +41,7 @@ int ompi_osc_ubcl_rget(void *origin_addr, size_t origin_count,
     size_t target_span;
     size_t target_iov_count;
     struct iovec *target_iov;
-    void *target_addr;
+    char *target_addr;
     mca_common_ubcl_endpoint_t *endpoint;
     ubcl_memory_descriptor_t sbuf_md;
     mca_osc_ubcl_module_t *module;
@@ -112,7 +112,10 @@ int ompi_osc_ubcl_rget(void *origin_addr, size_t origin_count,
 
     if (opal_convertor_on_device(&osc_req->origin_convertor)) {
         opal_free_list_return(&mca_osc_ubcl_component.req_free_list, &(osc_req->super));
-        mca_osc_ubcl_warn(OPAL_ERR_NOT_SUPPORTED, "GPU buffer not supported by osc/ubcl");
+        mca_osc_ubcl_error(
+            OPAL_ERR_NOT_SUPPORTED,
+            "GPU buffer not supported by osc/ubcl: cannot perform MPI_Get of buffer %p",
+            origin_addr);
         ret = OPAL_ERR_NOT_SUPPORTED;
         goto exit;
     }
diff --git a/ompi/mca/osc/ubcl/osc_ubcl_put.c b/ompi/mca/osc/ubcl/osc_ubcl_put.c
index ae45c45d511..17a7479e6a2 100644
--- a/ompi/mca/osc/ubcl/osc_ubcl_put.c
+++ b/ompi/mca/osc/ubcl/osc_ubcl_put.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2025-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -50,7 +50,7 @@ int ompi_osc_ubcl_rput(const void *origin_addr, size_t origin_count,
     size_t span;
     size_t target_iov_count;
     struct iovec *target_iov;
-    void *target_addr;
+    char *target_addr;
     mca_common_ubcl_endpoint_t *endpoint;
     ubcl_memory_descriptor_t sbuf_md;
     mca_osc_ubcl_module_t *module = (mca_osc_ubcl_module_t *) win->w_osc_module;
@@ -120,7 +120,10 @@ int ompi_osc_ubcl_rput(const void *origin_addr, size_t origin_count,
 
     if (opal_convertor_on_device(&osc_req->origin_convertor)) {
         opal_free_list_return(&mca_osc_ubcl_component.req_free_list, &(osc_req->super));
-        mca_osc_ubcl_warn(OPAL_ERR_NOT_SUPPORTED, "GPU buffer not supported by osc/ubcl");
+        mca_osc_ubcl_error(
+            OPAL_ERR_NOT_SUPPORTED,
+            "GPU buffer not supported by osc/ubcl: cannot perform MPI_Put of buffer %p",
+            origin_addr);
         ret = OPAL_ERR_NOT_SUPPORTED;
         goto exit;
     }
diff --git a/ompi/mca/osc/ucx/osc_ucx.h b/ompi/mca/osc/ucx/osc_ucx.h
index bc3dc8a91b3..f79db5d1070 100644
--- a/ompi/mca/osc/ucx/osc_ucx.h
+++ b/ompi/mca/osc/ucx/osc_ucx.h
@@ -27,6 +27,11 @@
 #define OMPI_OSC_UCX_POST_PEER_MAX 32
 #define OMPI_OSC_UCX_ATTACH_MAX    48
 #define OMPI_OSC_UCX_MEM_ADDR_MAX_LEN  1024
+/* Default number of RMA notification counters reserved per MPI process in each
+ * window's registered memory region.  Overridden per job by the
+ * osc_ucx_num_notify_counters MCA parameter and per window by the
+ * "mpi_assert_max_num_notify" info key. */
+#define OMPI_OSC_UCX_DEFAULT_NOTIFY_COUNTERS 16
 
 
 typedef struct ompi_osc_ucx_component {
@@ -43,6 +48,9 @@ typedef struct ompi_osc_ucx_component {
     bool no_locks; /* Default value of the no_locks info key for new windows */
     bool acc_single_intrinsic;
     unsigned int priority;
+    /* Number of notification counters reserved per MPI process in each window,
+     * unless the window's info gives "mpi_assert_max_num_notify". */
+    unsigned int num_notify_counters;
     /* directory where to place backing files */
     char *backing_directory;
 } ompi_osc_ucx_component_t;
@@ -122,6 +130,24 @@ typedef struct ompi_osc_ucx_module {
     struct ompi_communicator_t *comm;
     int flavor;
     size_t    size;
+    int *notify_counts;  /* per-rank number of notification counters *attached* at each
+                          * rank (size comm_size), as set by MPI_WIN_SET_NUM_NOTIFY and
+                          * kept consistent across the group by an allgather.  Always
+                          * <= notify_capacity. */
+    unsigned int notify_capacity; /* notification counters currently reserved per rank.
+                                   * Agreed on across the group and uniform.  Grown on
+                                   * demand by MPI_WIN_SET_NUM_NOTIFY unless
+                                   * notify_max_assert caps it. */
+    unsigned int notify_max_assert; /* non-zero only if *every* rank passed
+                                     * "mpi_assert_max_num_notify" at window creation.
+                                     * Then the agreed reservation is a hard cap and the
+                                     * counters never grow (MPI-5.1 12.2: the assertion
+                                     * lets the implementation optimize the allocation).
+                                     * Zero means no rank asserted a bound, so the
+                                     * standard's "does not assume any limit" applies. */
+    uint64_t *notify_addrs;  /* per-rank base address of the notification counters
+                              * (size comm_size) */
+    void *notify_base;       /* this rank's counters; notify_capacity uint64_t */
     size_t   *sizes; /* used if not every process has the same size */
     uint64_t *addrs;
     uint64_t *state_addrs;
@@ -149,6 +175,11 @@ typedef struct ompi_osc_ucx_module {
     opal_common_ucx_ctx_t *ctx;
     opal_common_ucx_wpmem_t *mem;
     opal_common_ucx_wpmem_t *state_mem;
+    /* Notification counters get their own registration rather than being
+     * appended to the window data: the data region for MPI_WIN_FLAVOR_CREATE
+     * belongs to the user and has no room for them, and a dynamic window has
+     * no data region at all. */
+    opal_common_ucx_wpmem_t *notify_mem;
     ompi_osc_ucx_mem_ranges_t *epoc_outstanding_ops_mems;
     bool skip_sync_check;
     bool noncontig_shared_win;
@@ -277,6 +308,75 @@ int ompi_osc_find_attached_region_position(ompi_osc_dynamic_win_info_t *dynamic_
 int ompi_osc_ucx_dynamic_lock(ompi_osc_ucx_module_t *module, int target);
 int ompi_osc_ucx_dynamic_unlock(ompi_osc_ucx_module_t *module, int target);
 
+int ompi_osc_ucx_put_notify(const void *origin_addr, size_t origin_count,
+                            struct ompi_datatype_t *origin_dt,
+                            int target, ptrdiff_t target_disp, size_t target_count,
+                            struct ompi_datatype_t *target_dt,
+                            int notify, struct ompi_win_t *win);
+int ompi_osc_ucx_get_notify(void *origin_addr, size_t origin_count,
+                            struct ompi_datatype_t *origin_dt,
+                            int target, ptrdiff_t target_disp, size_t target_count,
+                            struct ompi_datatype_t *target_dt,
+                            int notify, struct ompi_win_t *win);
+int ompi_osc_ucx_rput_notify(const void *origin_addr, size_t origin_count,
+                             struct ompi_datatype_t *origin_dt,
+                             int target, ptrdiff_t target_disp, size_t target_count,
+                             struct ompi_datatype_t *target_dt,
+                             int notify, struct ompi_win_t *win,
+                             struct ompi_request_t **request);
+int ompi_osc_ucx_rget_notify(void *origin_addr, size_t origin_count,
+                             struct ompi_datatype_t *origin_dt,
+                             int target, ptrdiff_t target_disp, size_t target_count,
+                             struct ompi_datatype_t *target_dt,
+                             int notify, struct ompi_win_t *win,
+                             struct ompi_request_t **request);
+int ompi_osc_ucx_accumulate_notify(const void *origin_addr, size_t origin_count,
+                                   struct ompi_datatype_t *origin_dt,
+                                   int target, ptrdiff_t target_disp, size_t target_count,
+                                   struct ompi_datatype_t *target_dt,
+                                   struct ompi_op_t *op, int notify,
+                                   struct ompi_win_t *win);
+int ompi_osc_ucx_get_accumulate_notify(const void *origin_addr, size_t origin_count,
+                                       struct ompi_datatype_t *origin_dt,
+                                       void *result_addr, size_t result_count,
+                                       struct ompi_datatype_t *result_dt,
+                                       int target, ptrdiff_t target_disp, size_t target_count,
+                                       struct ompi_datatype_t *target_dt,
+                                       struct ompi_op_t *op, int notify,
+                                       struct ompi_win_t *win);
+int ompi_osc_ucx_raccumulate_notify(const void *origin_addr, size_t origin_count,
+                                    struct ompi_datatype_t *origin_dt,
+                                    int target, ptrdiff_t target_disp, size_t target_count,
+                                    struct ompi_datatype_t *target_dt,
+                                    struct ompi_op_t *op, int notify,
+                                    struct ompi_win_t *win,
+                                    struct ompi_request_t **request);
+int ompi_osc_ucx_rget_accumulate_notify(const void *origin_addr, size_t origin_count,
+                                        struct ompi_datatype_t *origin_dt,
+                                        void *result_addr, size_t result_count,
+                                        struct ompi_datatype_t *result_dt,
+                                        int target, ptrdiff_t target_disp, size_t target_count,
+                                        struct ompi_datatype_t *target_dt,
+                                        struct ompi_op_t *op, int notify,
+                                        struct ompi_win_t *win,
+                                        struct ompi_request_t **request);
+int ompi_osc_ucx_win_get_notify_value(struct ompi_win_t *win, int notify,
+                                      OMPI_MPI_COUNT_TYPE *value);
+int ompi_osc_ucx_win_get_notify_bounds(struct ompi_win_t *win, int *num_sb, int *num_ub,
+                                       OMPI_MPI_COUNT_TYPE *value_ub);
+int ompi_osc_ucx_win_reset_notify_value(struct ompi_win_t *win, int notify,
+                                        OMPI_MPI_COUNT_TYPE *value);
+int ompi_osc_ucx_win_set_num_notify(struct ompi_win_t *win, struct opal_info_t *info,
+                                     int num_notifications);
+/* Collectively re-reserve new_capacity notification counters per rank, replacing
+ * the current registration.  Defined in osc_ucx_component.c because it needs the
+ * component's address-exchange helper. */
+int ompi_osc_ucx_grow_notify_counters(ompi_osc_ucx_module_t *module,
+                                      unsigned int new_capacity);
+
+int ompi_osc_ucx_win_get_num_notify(struct ompi_win_t *win, int target_rank,
+                                     int *num_notifications);
+
 /* returns the size at the peer */
 static inline size_t ompi_osc_ucx_get_size(ompi_osc_ucx_module_t *module, int rank)
 {
diff --git a/ompi/mca/osc/ucx/osc_ucx_comm.c b/ompi/mca/osc/ucx/osc_ucx_comm.c
index 0354edb71c0..1f400f85fb9 100644
--- a/ompi/mca/osc/ucx/osc_ucx_comm.c
+++ b/ompi/mca/osc/ucx/osc_ucx_comm.c
@@ -17,9 +17,15 @@
 #include "ompi/mca/osc/base/osc_base_obj_convert.h"
 #include "opal/mca/common/ucx/common_ucx.h"
 
+#include <stdint.h>
+
 #include "osc_ucx.h"
 #include "osc_ucx_request.h"
 
+#include <limits.h>
+
+#include "ompi/attribute/attribute.h"
+
 
 #define CHECK_VALID_RKEY(_module, _target, _count)                               \
     if (!((_module)->win_info_array[_target]).rkey_init && ((_count) > 0)) {     \
@@ -603,6 +609,589 @@ int ompi_osc_ucx_get(void *origin_addr, size_t origin_count,
     }
 }
 
+static int osc_ucx_request_over_flush(ompi_osc_ucx_module_t *module,
+                                      struct ompi_win_t *win, int target,
+                                      ucp_ep_h *ep, enum req_type req_type,
+                                      struct ompi_request_t **request);
+
+static int accumulate_req(const void *origin_addr, size_t origin_count,
+                          struct ompi_datatype_t *origin_dt,
+                          int target, ptrdiff_t target_disp, size_t target_count,
+                          struct ompi_datatype_t *target_dt,
+                          struct ompi_op_t *op, struct ompi_win_t *win,
+                          ompi_osc_ucx_accumulate_request_t *ucx_req);
+
+static int get_accumulate_req(const void *origin_addr, size_t origin_count,
+                              struct ompi_datatype_t *origin_dt,
+                              void *result_addr, size_t result_count,
+                              struct ompi_datatype_t *result_dt,
+                              int target, ptrdiff_t target_disp, size_t target_count,
+                              struct ompi_datatype_t *target_dt,
+                              struct ompi_op_t *op, struct ompi_win_t *win,
+                              ompi_osc_ucx_accumulate_request_t *ucx_req);
+
+/* Returns the remote address of notify counter[notify] for the given target.
+ * The counters have their own registered region (module->notify_mem), separate
+ * from the window data, so this is independent of the window's flavor and size. */
+static inline uint64_t
+osc_ucx_notify_counter_addr(ompi_osc_ucx_module_t *module, int target, int notify)
+{
+    return module->notify_addrs[target] + (uint64_t)notify * sizeof(uint64_t);
+}
+
+/* A region of module->notify_capacity notification counters is registered per
+ * rank at window creation (see osc_ucx_component.c), but only the first
+ * notify_counts[rank] of them are considered *attached* by
+ * MPI_WIN_SET_NUM_NOTIFY.  Per the MPI Standard it is erroneous to reference a
+ * counter that is out of range at the target, so validate against the target
+ * rank's attached count. */
+#define CHECK_NOTIFY_IDX(module, notify, rank)                                \
+    if ((notify) < 0 || (notify) >= (module)->notify_counts[rank]) {          \
+        return MPI_ERR_RMA_NOTIFICATION;                                      \
+    }
+
+/* Increments the target's notification counter once the preceding data
+ * operation has been ordered ahead of it.  Shared by every notified
+ * operation; they differ only in which base operation they issue first and
+ * in whether a fence or a flush is needed to order it.
+ *
+ * Note that for the request-based variants the data operation has already been
+ * issued and *request already handed back by the time this can fail, so an
+ * error return leaves that request outstanding and the caller still has to
+ * complete it.  A transport failure here is not recoverable in any case. */
+static inline int
+osc_ucx_notify_target(ompi_osc_ucx_module_t *module, int target, int notify,
+                      ucp_ep_h *ep)
+{
+    int ret = opal_common_ucx_wpmem_post(module->notify_mem,
+                                         UCP_ATOMIC_POST_OP_ADD, 1,
+                                         target, sizeof(uint64_t),
+                                         osc_ucx_notify_counter_addr(module, target, notify),
+                                         ep);
+    return (OPAL_SUCCESS == ret) ? OMPI_SUCCESS : OMPI_ERROR;
+}
+
+int ompi_osc_ucx_win_get_notify_value(struct ompi_win_t *win, int notify,
+                                      OMPI_MPI_COUNT_TYPE *value)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    int my_rank = ompi_comm_rank(module->comm);
+
+    CHECK_NOTIFY_IDX(module, notify, my_rank);
+
+    /* Origins increment this counter with a UCX atomic, which the transport may
+     * emulate in software on the local worker rather than offload to the NIC.
+     * In that case the counter only advances while the worker is progressed, so
+     * a consumer spinning on MPI_WIN_GET_NOTIFY_VALUE -- the natural way to wait
+     * for a notification -- would never observe the update.  Progress the worker
+     * here so that such a loop makes forward progress on its own, as every other
+     * spin-wait in this component does. */
+    opal_common_ucx_wpool_progress(mca_osc_ucx_component.wpool);
+
+    volatile uint64_t *counter =
+        (volatile uint64_t *)osc_ucx_notify_counter_addr(module, my_rank, notify);
+    *value = (OMPI_MPI_COUNT_TYPE)*counter;
+    opal_atomic_rmb();
+    return OMPI_SUCCESS;
+}
+
+int ompi_osc_ucx_win_reset_notify_value(struct ompi_win_t *win, int notify,
+                                        OMPI_MPI_COUNT_TYPE *value)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    int my_rank = ompi_comm_rank(module->comm);
+    uint64_t result_value = 0;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, my_rank);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, my_rank);
+
+    /* The counter is incremented by remote origins through UCX network atomic
+     * operations, so reset it with a UCX atomic swap (targeting our own rank)
+     * rather than a CPU atomic. That keeps the read-and-zero atomic with
+     * respect to those concurrent network atomics — a plain CPU swap is not
+     * ordered against them. The fetch returns the counter's previous value. */
+    ret = opal_common_ucx_wpmem_fetch(module->notify_mem,
+                                      UCP_ATOMIC_FETCH_OP_SWAP, 0,
+                                      my_rank, &result_value, sizeof(result_value),
+                                      osc_ucx_notify_counter_addr(module, my_rank, notify),
+                                      ep);
+    if (OPAL_SUCCESS != ret) {
+        OSC_UCX_VERBOSE(1, "opal_common_ucx_wpmem_fetch failed: %d", ret);
+        return OMPI_ERROR;
+    }
+
+    *value = (OMPI_MPI_COUNT_TYPE)result_value;
+    return OMPI_SUCCESS;
+}
+
+int ompi_osc_ucx_win_get_num_notify(struct ompi_win_t *win, int target_rank,
+                                     int *num_notifications)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+
+    if (target_rank < 0 || target_rank >= ompi_comm_size(module->comm)) {
+        return MPI_ERR_RANK;
+    }
+
+    /* Local query (MPI_WIN_GET_NUM_NOTIFY, §12.6.1): return the number of
+     * notification counters currently attached at target_rank, as last
+     * published by MPI_WIN_SET_NUM_NOTIFY. */
+    *num_notifications = module->notify_counts[target_rank];
+    return OMPI_SUCCESS;
+}
+
+int ompi_osc_ucx_win_set_num_notify(struct ompi_win_t *win, struct opal_info_t *info,
+                                     int num_notifications)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    int comm_size = ompi_comm_size(module->comm);
+    int requested = num_notifications;
+    int *requested_counts;
+    unsigned int needed;
+    int ret, i;
+
+    (void) info; /* "mpi_assert_same_num_notifications" is an optimization hint only */
+
+    /* When every rank asserted "mpi_assert_max_num_notify" at window creation,
+     * that value is a hard upper bound and asking for more is erroneous.
+     * Otherwise MPI-5.1 12.2 says no limit is assumed, so a request above the
+     * current reservation grows the counters below rather than failing.
+     *
+     * This is a synchronizing collective, so a rank with a bad argument must not
+     * return before the allgather below -- that would leave the rest of the
+     * group blocked in it.  Mark the request instead and let every rank discover
+     * the error from the gathered values. */
+    if (requested < 0 ||
+        (0 != module->notify_max_assert &&
+         (unsigned int) requested > module->notify_max_assert)) {
+        requested = -1;
+    }
+
+    requested_counts = malloc(comm_size * sizeof(int));
+    if (NULL == requested_counts) {
+        return OMPI_ERR_TEMP_OUT_OF_RESOURCE;
+    }
+
+    /* All notification counters (existing and newly attached) are reset to zero
+     * by this call.  Resetting before the allgather is what makes the standard's
+     * "will not return until ... all processes have adjusted the number of
+     * notification counters" hold: completing the collective implies every rank
+     * has already reset, so no rank can return and then have a peer wipe the
+     * notification it just delivered.  It is erroneous to call this while an
+     * access epoch is open, so no concurrent network atomics touch the counters
+     * and a plain local reset is sufficient. */
+    if (NULL != module->notify_base) {
+        memset(module->notify_base, 0, module->notify_capacity * sizeof(uint64_t));
+    }
+    opal_atomic_wmb();
+
+    /* Publish every rank's requested count to the whole group so that origins
+     * can validate notification indices against the target's count.  Gathering
+     * the requested value directly is what makes MPI_WIN_GET_NUM_NOTIFY return
+     * the value given here, including when it lowers the count. */
+    ret = module->comm->c_coll->coll_allgather(&requested, 1, MPI_INT,
+                                               requested_counts, 1, MPI_INT,
+                                               module->comm,
+                                               module->comm->c_coll->coll_allgather_module);
+    if (OMPI_SUCCESS != ret) {
+        free(requested_counts);
+        return ret;
+    }
+
+    for (i = 0; i < comm_size; i++) {
+        if (0 > requested_counts[i]) {
+            /* Some rank asked for a count outside [0, notify_capacity].  Every
+             * rank sees the same gathered array and bails identically, so the
+             * attached counts stay as they were rather than the group ending up
+             * half-reconfigured.  The counters have been zeroed, which is
+             * harmless for a call that is erroneous anyway. */
+            free(requested_counts);
+            return MPI_ERR_ARG;
+        }
+    }
+
+    /* Every rank sees the same gathered array, so they all reach the same
+     * decision about whether to grow and to what size, without extra
+     * communication.  The reservation is uniform across the window (window
+     * creation agrees it with an allreduce), so it grows to the largest request
+     * anyone made.  Never shrink: a rank that lowered its count keeps the space
+     * it already has, so only genuine growth costs a re-registration and
+     * alternating high/low requests do not thrash the NIC. */
+    needed = module->notify_capacity;
+    for (i = 0; i < comm_size; i++) {
+        if ((unsigned int) requested_counts[i] > needed) {
+            needed = (unsigned int) requested_counts[i];
+        }
+    }
+
+    if (needed > module->notify_capacity) {
+        ret = ompi_osc_ucx_grow_notify_counters(module, needed);
+        if (OMPI_SUCCESS != ret) {
+            free(requested_counts);
+            return ret;
+        }
+
+        /* MPI_WIN_NOTIFICATION_NUM_SB is the count supported without paying for
+         * a re-registration, so it has to follow the reservation rather than
+         * stay at whatever was cached when the window was created. */
+        ret = ompi_attr_set_int(WIN_ATTR, win, &win->w_keyhash,
+                                MPI_WIN_NOTIFICATION_NUM_SB,
+                                (int) module->notify_capacity, true);
+        if (OMPI_SUCCESS != ret) {
+            free(requested_counts);
+            return ret;
+        }
+    }
+
+    memcpy(module->notify_counts, requested_counts, comm_size * sizeof(int));
+    free(requested_counts);
+
+    return OMPI_SUCCESS;
+}
+
+int ompi_osc_ucx_win_get_notify_bounds(struct ompi_win_t *win, int *num_sb, int *num_ub,
+                                       OMPI_MPI_COUNT_TYPE *value_ub)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+
+    /* The current reservation is what is supported without paying for a
+     * re-registration, so it is the suggested bound.  The hard bound is only
+     * real when every rank asserted "mpi_assert_max_num_notify" at window
+     * creation; otherwise MPI_WIN_SET_NUM_NOTIFY grows the counters on demand
+     * and the only limit is what can be allocated.  Neither depends on the
+     * window's flavor. */
+    *num_sb = (int) module->notify_capacity;
+    *num_ub = (0 != module->notify_max_assert) ? (int) module->notify_max_assert
+                                               : INT_MAX;
+
+    /* Counters are uint64_t and only ever incremented by one per notified
+     * operation, but they are returned to the user as a signed MPI_Count, so
+     * the representable maximum of that type is the real bound. */
+    *value_ub = (OMPI_MPI_COUNT_TYPE) INT64_MAX;
+
+    return OMPI_SUCCESS;
+}
+
+int ompi_osc_ucx_put_notify(const void *origin_addr, size_t origin_count,
+                            struct ompi_datatype_t *origin_dt,
+                            int target, ptrdiff_t target_disp, size_t target_count,
+                            struct ompi_datatype_t *target_dt,
+                            int notify, struct ompi_win_t *win)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = ompi_osc_ucx_put(origin_addr, origin_count, origin_dt,
+                           target, target_disp, target_count, target_dt, win);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Flush to ensure the PUT is visible at the target before the counter
+     * increment arrives. */
+    ret = opal_common_ucx_wpmem_fence(module->mem);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    /* Atomically increment the target's notify counter in-place using the
+     * same mem handle as the window data. */
+    return osc_ucx_notify_target(module, target, notify, ep);
+}
+
+int ompi_osc_ucx_get_notify(void *origin_addr, size_t origin_count,
+                            struct ompi_datatype_t *origin_dt,
+                            int target, ptrdiff_t target_disp, size_t target_count,
+                            struct ompi_datatype_t *target_dt,
+                            int notify, struct ompi_win_t *win)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = ompi_osc_ucx_get(origin_addr, origin_count, origin_dt,
+                           target, target_disp, target_count, target_dt, win);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Flush to ensure the GET data is locally available before issuing the
+     * counter increment back to the target. */
+    ret = opal_common_ucx_ctx_flush(module->ctx, OPAL_COMMON_UCX_SCOPE_EP, target);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    return osc_ucx_notify_target(module, target, notify, ep);
+}
+
+int ompi_osc_ucx_rput_notify(const void *origin_addr, size_t origin_count,
+                             struct ompi_datatype_t *origin_dt,
+                             int target, ptrdiff_t target_disp, size_t target_count,
+                             struct ompi_datatype_t *target_dt,
+                             int notify, struct ompi_win_t *win,
+                             struct ompi_request_t **request)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = check_sync_state(module, target, true);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Issue the data movement and the notification first, and only then build
+     * the request over a flush -- that way the flush covers both, so completing
+     * the request means the counter update has been pushed out and not merely
+     * queued behind the origin's next MPI call. */
+    ret = ompi_osc_ucx_put(origin_addr, origin_count, origin_dt, target,
+                           target_disp, target_count, target_dt, win);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Fence to order the PUT before the counter increment. */
+    ret = opal_common_ucx_wpmem_fence(module->mem);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    ret = osc_ucx_notify_target(module, target, notify, ep);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    return osc_ucx_request_over_flush(module, win, target, ep, RPUT_REQ, request);
+}
+
+int ompi_osc_ucx_rget_notify(void *origin_addr, size_t origin_count,
+                             struct ompi_datatype_t *origin_dt,
+                             int target, ptrdiff_t target_disp, size_t target_count,
+                             struct ompi_datatype_t *target_dt,
+                             int notify, struct ompi_win_t *win,
+                             struct ompi_request_t **request)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = check_sync_state(module, target, true);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* As in rput_notify, the data movement and the notification both precede
+     * the request-bearing flush so that the request covers both. */
+    ret = ompi_osc_ucx_get(origin_addr, origin_count, origin_dt, target,
+                           target_disp, target_count, target_dt, win);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Blocking flush: the notification tells the target its window has been
+     * read, so the GET must have completed before the counter is incremented
+     * (MPI-5.1 12.6.4 requires that order). */
+    ret = opal_common_ucx_ctx_flush(module->ctx, OPAL_COMMON_UCX_SCOPE_EP, target);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    ret = osc_ucx_notify_target(module, target, notify, ep);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    return osc_ucx_request_over_flush(module, win, target, ep, RGET_REQ, request);
+}
+
+int ompi_osc_ucx_accumulate_notify(const void *origin_addr, size_t origin_count,
+                                   struct ompi_datatype_t *origin_dt,
+                                   int target, ptrdiff_t target_disp, size_t target_count,
+                                   struct ompi_datatype_t *target_dt,
+                                   struct ompi_op_t *op, int notify,
+                                   struct ompi_win_t *win)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = ompi_osc_ucx_accumulate(origin_addr, origin_count, origin_dt,
+                                  target, target_disp, target_count, target_dt,
+                                  op, win);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Fence so that the accumulate is applied at the target before the counter
+     * increment, as §12.6.4 requires. */
+    ret = opal_common_ucx_wpmem_fence(module->mem);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    return osc_ucx_notify_target(module, target, notify, ep);
+}
+
+int ompi_osc_ucx_get_accumulate_notify(const void *origin_addr, size_t origin_count,
+                                       struct ompi_datatype_t *origin_dt,
+                                       void *result_addr, size_t result_count,
+                                       struct ompi_datatype_t *result_dt,
+                                       int target, ptrdiff_t target_disp, size_t target_count,
+                                       struct ompi_datatype_t *target_dt,
+                                       struct ompi_op_t *op, int notify,
+                                       struct ompi_win_t *win)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = ompi_osc_ucx_get_accumulate(origin_addr, origin_count, origin_dt,
+                                      result_addr, result_count, result_dt,
+                                      target, target_disp, target_count, target_dt,
+                                      op, win);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Flush rather than fence: the result buffer must be locally valid, and the
+     * update must have been applied at the target, before the target may
+     * observe the notification. */
+    ret = opal_common_ucx_ctx_flush(module->ctx, OPAL_COMMON_UCX_SCOPE_EP, target);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    return osc_ucx_notify_target(module, target, notify, ep);
+}
+
+int ompi_osc_ucx_raccumulate_notify(const void *origin_addr, size_t origin_count,
+                                    struct ompi_datatype_t *origin_dt,
+                                    int target, ptrdiff_t target_disp, size_t target_count,
+                                    struct ompi_datatype_t *target_dt,
+                                    struct ompi_op_t *op, int notify,
+                                    struct ompi_win_t *win,
+                                    struct ompi_request_t **request)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = check_sync_state(module, target, true);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Passing a NULL request runs accumulate_req as the blocking accumulate: it
+     * ends with a blocking flush, so the read-modify-write has completed at the
+     * target before we return here.  The notification issued below is therefore
+     * correctly ordered after the window access (MPI-5.1 12.6.4).  Building our
+     * own request afterwards -- rather than taking the pre-completed one from
+     * ompi_osc_ucx_raccumulate -- is what lets that request also cover the
+     * notification. */
+    ret = accumulate_req(origin_addr, origin_count, origin_dt, target, target_disp,
+                         target_count, target_dt, op, win, NULL);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Fence to order the accumulate ahead of the counter increment. */
+    ret = opal_common_ucx_wpmem_fence(module->mem);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    ret = osc_ucx_notify_target(module, target, notify, ep);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* The accumulate is already complete, so the request only has to represent
+     * the notification reaching the wire; RPUT_REQ selects the plain
+     * flush-completion behaviour rather than the accumulate state machine. */
+    return osc_ucx_request_over_flush(module, win, target, ep, RPUT_REQ, request);
+}
+
+int ompi_osc_ucx_rget_accumulate_notify(const void *origin_addr, size_t origin_count,
+                                        struct ompi_datatype_t *origin_dt,
+                                        void *result_addr, size_t result_count,
+                                        struct ompi_datatype_t *result_dt,
+                                        int target, ptrdiff_t target_disp, size_t target_count,
+                                        struct ompi_datatype_t *target_dt,
+                                        struct ompi_op_t *op, int notify,
+                                        struct ompi_win_t *win,
+                                        struct ompi_request_t **request)
+{
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t *)win->w_osc_module;
+    ucp_ep_h *ep;
+    int ret;
+
+    CHECK_NOTIFY_IDX(module, notify, target);
+
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+
+    ret = check_sync_state(module, target, true);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* As in raccumulate_notify: a NULL request makes this the blocking form,
+     * which ends with a blocking flush, so both the fetched result and the
+     * update at the target are complete before the notification is issued. */
+    ret = get_accumulate_req(origin_addr, origin_count, origin_dt,
+                             result_addr, result_count, result_dt,
+                             target, target_disp, target_count, target_dt,
+                             op, win, NULL);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    /* Fence to order the accumulate ahead of the counter increment. */
+    ret = opal_common_ucx_wpmem_fence(module->mem);
+    if (OPAL_SUCCESS != ret) {
+        return OMPI_ERROR;
+    }
+
+    ret = osc_ucx_notify_target(module, target, notify, ep);
+    if (OMPI_SUCCESS != ret) {
+        return ret;
+    }
+
+    return osc_ucx_request_over_flush(module, win, target, ep, RGET_REQ, request);
+}
+
 static inline bool ompi_osc_need_acc_lock(ompi_osc_ucx_module_t *module, int target)
 {
     ompi_osc_ucx_lock_t *lock = NULL;
@@ -1490,31 +2079,30 @@ int ompi_osc_ucx_get_accumulate_nb(const void *origin_addr, size_t origin_count,
                             target_count, target_dt, op, win, GET_ACCUMULATE);
 }
 
-int ompi_osc_ucx_rput(const void *origin_addr, size_t origin_count,
-                      struct ompi_datatype_t *origin_dt,
-                      int target, ptrdiff_t target_disp, size_t target_count,
-                      struct ompi_datatype_t *target_dt,
-                      struct ompi_win_t *win, struct ompi_request_t **request) {
-    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t*) win->w_osc_module;
-    ucp_ep_h *ep;
-    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+/* Attach an MPI request to a nonblocking worker flush.
+ *
+ * The request completes when ucp_worker_flush_nb completes, and that flush
+ * covers every operation already issued on this worker -- whichever memory
+ * registration they used.  So the request waits for exactly what the caller
+ * issued *before* getting here.  The notified variants rely on this: they issue
+ * their counter atomic first, so completing the request implies the
+ * notification has been pushed to the target rather than left queued locally
+ * (MPI-5.1 12.6.4, advice to implementors).
+ *
+ * Allocating the request last also keeps the failure contract clean: anything
+ * that can fail has already run, so callers return their errors with *request
+ * untouched, as MPI expects of a call that reports an error. */
+static int osc_ucx_request_over_flush(ompi_osc_ucx_module_t *module,
+                                      struct ompi_win_t *win, int target,
+                                      ucp_ep_h *ep, enum req_type req_type,
+                                      struct ompi_request_t **request)
+{
     opal_common_ucx_wpmem_t *mem = module->mem;
     uint64_t remote_addr = (module->state_addrs[target]) + OSC_UCX_STATE_REQ_FLAG_OFFSET;
     ompi_osc_ucx_generic_request_t *ucx_req = NULL;
     int ret = OMPI_SUCCESS;
 
-    ret = check_sync_state(module, target, true);
-    if (ret != OMPI_SUCCESS) {
-        return ret;
-    }
-
-    ret = ompi_osc_ucx_put(origin_addr, origin_count, origin_dt, target, target_disp,
-                           target_count, target_dt, win);
-    if (ret != OMPI_SUCCESS) {
-        return ret;
-    }
-
-    OMPI_OSC_UCX_GENERIC_REQUEST_ALLOC(win, ucx_req, RPUT_REQ);
+    OMPI_OSC_UCX_GENERIC_REQUEST_ALLOC(win, ucx_req, req_type);
     ucx_req->super.module = module;
 
     OSC_UCX_INCREMENT_OUTSTANDING_NB_OPS(module);
@@ -1544,17 +2132,14 @@ int ompi_osc_ucx_rput(const void *origin_addr, size_t origin_count,
     return ret;
 }
 
-int ompi_osc_ucx_rget(void *origin_addr, size_t origin_count,
+int ompi_osc_ucx_rput(const void *origin_addr, size_t origin_count,
                       struct ompi_datatype_t *origin_dt,
                       int target, ptrdiff_t target_disp, size_t target_count,
-                      struct ompi_datatype_t *target_dt, struct ompi_win_t *win,
-                      struct ompi_request_t **request) {
+                      struct ompi_datatype_t *target_dt,
+                      struct ompi_win_t *win, struct ompi_request_t **request) {
     ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t*) win->w_osc_module;
     ucp_ep_h *ep;
     OSC_UCX_GET_DEFAULT_EP(ep, module, target);
-    opal_common_ucx_wpmem_t *mem = module->mem;
-    uint64_t remote_addr = (module->state_addrs[target]) + OSC_UCX_STATE_REQ_FLAG_OFFSET;
-    ompi_osc_ucx_generic_request_t *ucx_req = NULL;
     int ret = OMPI_SUCCESS;
 
     ret = check_sync_state(module, target, true);
@@ -1562,40 +2147,37 @@ int ompi_osc_ucx_rget(void *origin_addr, size_t origin_count,
         return ret;
     }
 
-    ret = ompi_osc_ucx_get(origin_addr, origin_count, origin_dt, target, target_disp,
+    ret = ompi_osc_ucx_put(origin_addr, origin_count, origin_dt, target, target_disp,
                            target_count, target_dt, win);
     if (ret != OMPI_SUCCESS) {
         return ret;
     }
 
-    OMPI_OSC_UCX_GENERIC_REQUEST_ALLOC(win, ucx_req, RGET_REQ);
-    ucx_req->super.module = module;
+    return osc_ucx_request_over_flush(module, win, target, ep, RPUT_REQ, request);
+}
 
-    OSC_UCX_INCREMENT_OUTSTANDING_NB_OPS(module);
-    ret = opal_common_ucx_wpmem_flush_ep_nb(mem, target, ompi_osc_ucx_req_completion, ucx_req, ep);
+int ompi_osc_ucx_rget(void *origin_addr, size_t origin_count,
+                      struct ompi_datatype_t *origin_dt,
+                      int target, ptrdiff_t target_disp, size_t target_count,
+                      struct ompi_datatype_t *target_dt, struct ompi_win_t *win,
+                      struct ompi_request_t **request) {
+    ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t*) win->w_osc_module;
+    ucp_ep_h *ep;
+    OSC_UCX_GET_DEFAULT_EP(ep, module, target);
+    int ret = OMPI_SUCCESS;
 
+    ret = check_sync_state(module, target, true);
     if (ret != OMPI_SUCCESS) {
-        /* fallback to using an atomic op to acquire a request handle */
-        ret = opal_common_ucx_wpmem_fence(mem);
-        if (ret != OMPI_SUCCESS) {
-            OSC_UCX_VERBOSE(1, "opal_common_ucx_mem_fence failed: %d", ret);
-            OMPI_OSC_UCX_REQUEST_RETURN(ucx_req);
-            return OMPI_ERROR;
-        }
-
-        ret = opal_common_ucx_wpmem_fetch_nb(mem, UCP_ATOMIC_FETCH_OP_FADD,
-                                            0, target, &(module->req_result),
-                                            sizeof(uint64_t), remote_addr & (~0x7),
-                                            ompi_osc_ucx_req_completion, ucx_req, ep);
-        if (ret != OMPI_SUCCESS) {
-            OMPI_OSC_UCX_REQUEST_RETURN(ucx_req);
-            return ret;
-        }
+        return ret;
     }
 
-    *request = &ucx_req->super.super;
+    ret = ompi_osc_ucx_get(origin_addr, origin_count, origin_dt, target, target_disp,
+                           target_count, target_dt, win);
+    if (ret != OMPI_SUCCESS) {
+        return ret;
+    }
 
-    return ret;
+    return osc_ucx_request_over_flush(module, win, target, ep, RGET_REQ, request);
 }
 
 int ompi_osc_ucx_raccumulate(const void *origin_addr, size_t origin_count,
diff --git a/ompi/mca/osc/ucx/osc_ucx_component.c b/ompi/mca/osc/ucx/osc_ucx_component.c
index 635a53a3e0f..4c33b366543 100644
--- a/ompi/mca/osc/ucx/osc_ucx_component.c
+++ b/ompi/mca/osc/ucx/osc_ucx_component.c
@@ -25,6 +25,10 @@
 #include "osc_ucx.h"
 #include "osc_ucx_request.h"
 #include "opal/util/sys_limits.h"
+#include "opal/util/info.h"
+#include "opal/class/opal_cstring.h"
+
+#include <limits.h>
 
 #define memcpy_off(_dst, _src, _len, _off)        \
     memcpy(((char*)(_dst)) + (_off), _src, _len); \
@@ -102,6 +106,20 @@ ompi_osc_ucx_module_t ompi_osc_ucx_module_template = {
         .osc_fetch_and_op = ompi_osc_ucx_fetch_and_op,
         .osc_get_accumulate = ompi_osc_ucx_get_accumulate,
 
+        .osc_put_notify = ompi_osc_ucx_put_notify,
+        .osc_get_notify = ompi_osc_ucx_get_notify,
+        .osc_rput_notify = ompi_osc_ucx_rput_notify,
+        .osc_rget_notify = ompi_osc_ucx_rget_notify,
+        .osc_accumulate_notify = ompi_osc_ucx_accumulate_notify,
+        .osc_get_accumulate_notify = ompi_osc_ucx_get_accumulate_notify,
+        .osc_raccumulate_notify = ompi_osc_ucx_raccumulate_notify,
+        .osc_rget_accumulate_notify = ompi_osc_ucx_rget_accumulate_notify,
+        .osc_win_get_notify_value = ompi_osc_ucx_win_get_notify_value,
+        .osc_win_reset_notify_value = ompi_osc_ucx_win_reset_notify_value,
+        .osc_win_set_num_notify = ompi_osc_ucx_win_set_num_notify,
+        .osc_win_get_num_notify = ompi_osc_ucx_win_get_num_notify,
+        .osc_win_get_notify_bounds = ompi_osc_ucx_win_get_notify_bounds,
+
         .osc_rput = ompi_osc_ucx_rput,
         .osc_rget = ompi_osc_ucx_rget,
         .osc_raccumulate = ompi_osc_ucx_raccumulate,
@@ -150,6 +168,53 @@ static bool check_config_value_bool (char *key, opal_info_t *info)
     return flag_value[0];
 }
 
+/* Read the mpi_assert_max_num_notify info key (MPI-5.1 section 12.2) to decide
+ * how many notification counters to reserve per MPI process initially, and
+ * report in *asserted whether the key was actually given.
+ *
+ * The key is an assertion by the caller that it will not ask
+ * MPI_WIN_SET_NUM_NOTIFY for more than this, which lets us size the
+ * registration once and treat it as a hard upper bound.  Without it the
+ * standard is explicit that "the implementation does not assume any limit", so
+ * the reservation is only a starting size and the counters grow on demand. */
+static int osc_ucx_reserved_notify_counters(opal_info_t *info, unsigned int *reserved,
+                                            bool *asserted)
+{
+    opal_cstring_t *value_string;
+    int flag = 0, value = 0;
+
+    *reserved = mca_osc_ucx_component.num_notify_counters;
+    *asserted = false;
+
+    if (NULL == info) {
+        return OMPI_SUCCESS;
+    }
+
+    if (OMPI_SUCCESS != opal_info_get(info, "mpi_assert_max_num_notify",
+                                      &value_string, &flag) || !flag) {
+        return OMPI_SUCCESS;
+    }
+
+    if (OPAL_SUCCESS != opal_cstring_to_int(value_string, &value)) {
+        OBJ_RELEASE(value_string);
+        return MPI_ERR_INFO;
+    }
+    OBJ_RELEASE(value_string);
+
+    /* A negative value is a malformed key rather than "no assertion"; only 0
+     * carries the "assume nothing" meaning. */
+    if (value < 0) {
+        return MPI_ERR_INFO;
+    }
+
+    if (0 != value) {
+        *reserved = (unsigned int) value;
+        *asserted = true;
+    }
+
+    return OMPI_SUCCESS;
+}
+
 static int component_open(void) {
     opal_common_ucx_mca_register();
 
@@ -220,6 +285,23 @@ static int component_register(void) {
                                            MCA_BASE_VAR_SCOPE_GROUP, &ompi_osc_ucx_outstanding_ops_flush_threshold);
     free(description_str);
 
+    mca_osc_ucx_component.num_notify_counters = OMPI_OSC_UCX_DEFAULT_NOTIFY_COUNTERS;
+
+    opal_asprintf(&description_str,
+                  "Number of RMA notification counters reserved per MPI process "
+                  "in the registered memory region of each window.  Windows whose "
+                  "info gives an mpi_assert_max_num_notify value use that instead. "
+                  "This is a hard upper bound: the counters share the window's "
+                  "registration, so MPI_Win_set_num_notify cannot exceed it "
+                  "(default: %u)",
+                  mca_osc_ucx_component.num_notify_counters);
+    (void) mca_base_component_var_register(&mca_osc_ucx_component.super.osc_version,
+                                           "num_notify_counters", description_str,
+                                           MCA_BASE_VAR_TYPE_UNSIGNED_INT, NULL, 0, 0,
+                                           OPAL_INFO_LVL_3, MCA_BASE_VAR_SCOPE_GROUP,
+                                           &mca_osc_ucx_component.num_notify_counters);
+    free(description_str);
+
     opal_common_ucx_mca_var_register(&mca_osc_ucx_component.super.osc_version);
 
     if (0 == access ("/dev/shm", W_OK)) {
@@ -559,7 +641,8 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
     opal_common_ucx_mem_type_t mem_type;
     char *my_mem_addr;
     int my_mem_addr_size;
-    uint64_t my_info[3] = {0};
+    uint64_t my_info[4] = {0};
+    void *notify_base = NULL;
     char *recv_buf = NULL;
     void *dynamic_base = NULL;
     unsigned long adjusted_size = size;
@@ -672,6 +755,48 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
 
     module->flavor = flavor;
     module->size = size;
+
+    /* How many notification counters to reserve per MPI process.  Read before
+     * the counter region is allocated below.  A malformed info value must not
+     * make this rank skip the allreduce that follows -- that would leave the
+     * rest of the group blocked in window creation -- so the failure is carried
+     * through the collective as a negative reservation instead. */
+    unsigned int notify_reserved = 0;
+    bool notify_asserted = false;
+    int notify_values[3];
+    /* The reservation is exchanged as an int and is used to size an allocation,
+     * so a value that does not fit is a bad configuration rather than a request
+     * to honor.  Both failures ride the flag, not the value: MPI_MAX would hide
+     * a sentinel value behind some other rank's larger reservation. */
+    bool notify_bad = (OMPI_SUCCESS != osc_ucx_reserved_notify_counters(info, &notify_reserved,
+                                                                        &notify_asserted))
+                      || notify_reserved > (unsigned int) INT_MAX;
+    notify_values[0] = notify_bad ? 1 : 0;
+    notify_values[1] = notify_bad ? 0 : (int) notify_reserved;
+    /* Carried as "some rank did NOT assert" so that it combines under MPI_MAX
+     * along with the other two values. */
+    notify_values[2] = notify_asserted ? 0 : 1;
+
+    /* info is allowed to differ between MPI processes, so agree on one
+     * reservation for the whole window.  Taking the maximum keeps every rank's
+     * own assertion satisfiable, and propagates any rank's failure flag. */
+    ret = module->comm->c_coll->coll_allreduce(MPI_IN_PLACE, notify_values, 3,
+                                              MPI_INT, MPI_MAX, module->comm,
+                                              module->comm->c_coll->coll_allreduce_module);
+    if (OMPI_SUCCESS != ret) {
+        goto error;
+    }
+    if (0 != notify_values[0]) {
+        ret = MPI_ERR_INFO;
+        goto error;
+    }
+    module->notify_capacity = (unsigned int) notify_values[1];
+    /* Only treat the reservation as a hard cap when *every* rank asserted a
+     * bound.  A rank that gave no key made no promise, so the window has to
+     * stay growable for it -- MPI-5.1 12.2 says an absent (zero) key means the
+     * implementation assumes no limit. */
+    module->notify_max_assert = notify_values[2] ? 0 : (unsigned int) notify_values[1];
+
     module->no_locks = check_config_value_bool ("no_locks", info);
     module->acc_single_intrinsic = check_config_value_bool ("acc_single_intrinsic", info);
     module->skip_sync_check = false;
@@ -849,7 +974,6 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
             goto error;
         }
 
-
         for (i = 0, total = 0; i < comm_size ; ++i) {
             size_t peer_size = ompi_osc_ucx_get_size(module, i);
             if (peer_size || !module->noncontig_shared_win) {
@@ -884,7 +1008,8 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
         ret = OMPI_ERR_BAD_PARAM;
         goto error;
     }
-    ret = opal_common_ucx_wpmem_create(module->ctx, mem_base, module->size,
+    ret = opal_common_ucx_wpmem_create(module->ctx, mem_base,
+                                     module->size,
                                      mem_type, &exchange_len_info,
                                      OPAL_COMMON_UCX_WPMEM_ADDR_EXCHANGE_FULL,
                                      (void *)module->comm,
@@ -899,6 +1024,37 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
         ucp_rkey_buffer_release(my_mem_addr);
     }
 
+    /* Notification counters live in their own registered region, like the
+     * window state does.  Appending them to the window data would mean writing
+     * past the end of the user's buffer for MPI_WIN_FLAVOR_CREATE, and would
+     * leave dynamic windows -- which have no data region -- with nowhere to put
+     * them. */
+    if (0 != module->notify_capacity) {
+        module->notify_base = calloc(module->notify_capacity, sizeof(uint64_t));
+        if (NULL == module->notify_base) {
+            ret = OMPI_ERR_TEMP_OUT_OF_RESOURCE;
+            goto error;
+        }
+
+        notify_base = module->notify_base;
+        ret = opal_common_ucx_wpmem_create(module->ctx, &notify_base,
+                                         module->notify_capacity * sizeof(uint64_t),
+                                         OPAL_COMMON_UCX_MEM_MAP,
+                                         &exchange_len_info,
+                                         OPAL_COMMON_UCX_WPMEM_ADDR_EXCHANGE_FULL,
+                                         (void *)module->comm,
+                                         &my_mem_addr, &my_mem_addr_size,
+                                         &module->notify_mem);
+        if (ret != OMPI_SUCCESS) {
+            goto error;
+        }
+
+        if (my_mem_addr_size != 0) {
+            /* rkey object is already distributed among comm processes */
+            ucp_rkey_buffer_release(my_mem_addr);
+        }
+    }
+
     state_base = (void *)&(module->state);
     ret = opal_common_ucx_wpmem_create(module->ctx, &state_base,
                                      sizeof(ompi_osc_ucx_state_t),
@@ -926,6 +1082,7 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
     }
     my_info[1] = (uint64_t)state_base;
     my_info[2] = ompi_comm_rank(&ompi_mpi_comm_world.comm);
+    my_info[3] = (uint64_t)module->notify_base;
 
     recv_buf = (char *)calloc(comm_size, sizeof(my_info));
     ret = comm->c_coll->coll_allgather((void *)my_info, sizeof(my_info),
@@ -941,10 +1098,17 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
     module->addrs = calloc(comm_size, sizeof(uint64_t));
     module->state_addrs = calloc(comm_size, sizeof(uint64_t));
     module->comm_world_ranks = calloc(comm_size, sizeof(uint64_t));
+    /* Number of notification counters attached at each rank; starts at zero
+     * everywhere (consistent without communication) and is updated by
+     * MPI_WIN_SET_NUM_NOTIFY.  Counters must be attached before use. */
+    module->notify_counts = calloc(comm_size, sizeof(int));
+    module->notify_addrs = calloc(comm_size, sizeof(uint64_t));
     for (i = 0; i < comm_size; i++) {
-        memcpy(&(module->addrs[i]), recv_buf + i * 3 * sizeof(uint64_t), sizeof(uint64_t));
-        memcpy(&(module->state_addrs[i]), recv_buf + i * 3 * sizeof(uint64_t) + sizeof(uint64_t), sizeof(uint64_t));
-        memcpy(&(module->comm_world_ranks[i]), recv_buf + i * 3 * sizeof(uint64_t) + 2 * sizeof(uint64_t), sizeof(uint64_t));
+        const char *entry = recv_buf + i * sizeof(my_info);
+        memcpy(&(module->addrs[i]), entry, sizeof(uint64_t));
+        memcpy(&(module->state_addrs[i]), entry + sizeof(uint64_t), sizeof(uint64_t));
+        memcpy(&(module->comm_world_ranks[i]), entry + 2 * sizeof(uint64_t), sizeof(uint64_t));
+        memcpy(&(module->notify_addrs[i]), entry + 3 * sizeof(uint64_t), sizeof(uint64_t));
     }
     free(recv_buf);
 
@@ -957,6 +1121,7 @@ static int component_select(struct ompi_win_t *win, void **base, size_t size, pt
     module->state.acc_lock = TARGET_LOCK_UNLOCKED;
     module->state.dynamic_lock = TARGET_LOCK_UNLOCKED;
     module->state.dynamic_win_count = 0;
+
     for (i = 0; i < OMPI_OSC_UCX_ATTACH_MAX; i++) {
         module->local_dynamic_win_info[i].refcnt = 0;
     }
@@ -1091,6 +1256,92 @@ int ompi_osc_ucx_dynamic_unlock(ompi_osc_ucx_module_t *module, int target) {
     return OMPI_SUCCESS;
 }
 
+/* Collectively replace the notification-counter registration with a larger one.
+ *
+ * Called from MPI_WIN_SET_NUM_NOTIFY, which the standard defines as a blocking,
+ * synchronizing collective procedure -- that is what makes this safe.  Every
+ * rank has to take part even if its own request fits, because registering the
+ * memory exchanges rkeys with the whole group.
+ *
+ * Two properties of MPI_WIN_SET_NUM_NOTIFY keep this simple.  It resets every
+ * counter to zero, so a freshly calloc'd region is already the required
+ * contents and no value has to be carried across.  And it is erroneous to call
+ * it while an access epoch is open or with an active notification-threshold
+ * request, so no remote atomic can be in flight against the old region while it
+ * is being replaced.
+ *
+ * The allgather of the new base addresses doubles as the barrier that lets the
+ * old region be released: once it completes, every rank has published its new
+ * address and no rank can issue a notified operation until it returns from the
+ * enclosing collective. */
+int ompi_osc_ucx_grow_notify_counters(ompi_osc_ucx_module_t *module,
+                                      unsigned int new_capacity)
+{
+    int comm_size = ompi_comm_size(module->comm);
+    opal_common_ucx_wpmem_t *new_mem = NULL;
+    void *new_base = NULL, *reg_base;
+    char *my_mem_addr = NULL;
+    uint64_t my_addr, *new_addrs = NULL;
+    int my_mem_addr_size = 0;
+    int ret;
+
+    new_base = calloc(new_capacity, sizeof(uint64_t));
+    if (NULL == new_base) {
+        return MPI_ERR_NO_MEM;
+    }
+
+    new_addrs = calloc(comm_size, sizeof(uint64_t));
+    if (NULL == new_addrs) {
+        free(new_base);
+        return MPI_ERR_NO_MEM;
+    }
+
+    reg_base = new_base;
+    ret = opal_common_ucx_wpmem_create(module->ctx, &reg_base,
+                                       new_capacity * sizeof(uint64_t),
+                                       OPAL_COMMON_UCX_MEM_MAP,
+                                       &exchange_len_info,
+                                       OPAL_COMMON_UCX_WPMEM_ADDR_EXCHANGE_FULL,
+                                       (void *)module->comm,
+                                       &my_mem_addr, &my_mem_addr_size,
+                                       &new_mem);
+    if (OMPI_SUCCESS != ret) {
+        free(new_addrs);
+        free(new_base);
+        return ret;
+    }
+
+    if (0 != my_mem_addr_size) {
+        /* rkey object is already distributed among comm processes */
+        ucp_rkey_buffer_release(my_mem_addr);
+    }
+
+    my_addr = (uint64_t) new_base;
+    ret = module->comm->c_coll->coll_allgather(&my_addr, sizeof(uint64_t), MPI_BYTE,
+                                               new_addrs, sizeof(uint64_t), MPI_BYTE,
+                                               module->comm,
+                                               module->comm->c_coll->coll_allgather_module);
+    if (OMPI_SUCCESS != ret) {
+        opal_common_ucx_wpmem_free(new_mem);
+        free(new_addrs);
+        free(new_base);
+        return ret;
+    }
+
+    if (NULL != module->notify_mem) {
+        opal_common_ucx_wpmem_free(module->notify_mem);
+    }
+    free(module->notify_base);
+    free(module->notify_addrs);
+
+    module->notify_mem = new_mem;
+    module->notify_base = new_base;
+    module->notify_addrs = new_addrs;
+    module->notify_capacity = new_capacity;
+
+    return OMPI_SUCCESS;
+}
+
 int ompi_osc_ucx_win_attach(struct ompi_win_t *win, void *base, size_t len) {
     ompi_osc_ucx_module_t *module = (ompi_osc_ucx_module_t*) win->w_osc_module;
     int insert_index = -1, contain_index;
@@ -1245,11 +1496,17 @@ int ompi_osc_ucx_free(struct ompi_win_t *win) {
     free(module->addrs);
     free(module->state_addrs);
     free(module->comm_world_ranks);
+    free(module->notify_counts);
+    free(module->notify_addrs);
 
     opal_common_ucx_wpmem_free(module->state_mem);
     if (NULL != module->mem) {
         opal_common_ucx_wpmem_free(module->mem);
     }
+    if (NULL != module->notify_mem) {
+        opal_common_ucx_wpmem_free(module->notify_mem);
+    }
+    free(module->notify_base);
 
     opal_common_ucx_wpctx_release(module->ctx);
 
diff --git a/ompi/mca/part/persist/part_persist.h b/ompi/mca/part/persist/part_persist.h
index 86fb9bac42d..57faeed82ec 100644
--- a/ompi/mca/part/persist/part_persist.h
+++ b/ompi/mca/part/persist/part_persist.h
@@ -242,7 +242,7 @@ mca_part_persist_progress(void)
 
                     err = opal_datatype_type_size(&(req->req_datatype->super), &dt_size_);
                     if(OMPI_SUCCESS != err) return OMPI_ERROR;
-                    dt_size = (dt_size_ > (size_t) UINT_MAX) ? MPI_UNDEFINED : (uint32_t) dt_size_;
+                    dt_size = (dt_size_ > (size_t) UINT_MAX) ? (uint32_t)MPI_UNDEFINED : (uint32_t) dt_size_;
                     uint32_t bytes = req->real_count * dt_size;
 
                     /* Set up persistent sends */
@@ -263,7 +263,7 @@ mca_part_persist_progress(void)
 
                     err = opal_datatype_type_size(&(req->req_datatype->super), &dt_size_);
                     if(OMPI_SUCCESS != err) return OMPI_ERROR;
-                    dt_size = (dt_size_ > (size_t) UINT_MAX) ? MPI_UNDEFINED : (uint32_t) dt_size_;
+                    dt_size = (dt_size_ > (size_t) UINT_MAX) ? (uint32_t)MPI_UNDEFINED : (uint32_t) dt_size_;
                     uint32_t bytes = req->real_count * dt_size;
 
 
@@ -382,7 +382,7 @@ mca_part_persist_precv_init(void *buf,
     /* Compute total number of bytes */
     err = opal_datatype_type_size(&(req->req_datatype->super), &dt_size_);
     if(OMPI_SUCCESS != err) return OMPI_ERROR;
-    dt_size = (dt_size_ > (size_t) UINT_MAX) ? MPI_UNDEFINED : (uint32_t) dt_size_;
+    dt_size = (dt_size_ > (size_t) UINT_MAX) ? (uint32_t)MPI_UNDEFINED : (uint32_t) dt_size_;
     req->req_bytes = parts * count * dt_size;
 
     /* Set ompi request initial values */
@@ -442,7 +442,7 @@ mca_part_persist_psend_init(const void* buf,
     /* Determine total bytes to send. */
     err = opal_datatype_type_size(&(req->req_datatype->super), &dt_size_);
     if(OMPI_SUCCESS != err) return OMPI_ERROR;
-    dt_size = (dt_size_ > (size_t) UINT_MAX) ? MPI_UNDEFINED : (uint32_t) dt_size_;
+    dt_size = (dt_size_ > (size_t) UINT_MAX) ? (uint32_t)MPI_UNDEFINED : (uint32_t) dt_size_;
     req->req_bytes = parts * count * dt_size;
 
     /* non-blocking send set-up data */
@@ -525,7 +525,6 @@ mca_part_persist_start(size_t count, ompi_request_t** requests)
         req->req_ompi.req_status.MPI_ERROR = OMPI_SUCCESS;
         req->req_ompi.req_status._cancelled = 0;
         req->req_part_complete = false;
-        req->req_ompi.req_complete = false;
         OPAL_ATOMIC_SWAP_PTR(&req->req_ompi.req_complete, REQUEST_PENDING);   
     }
 
@@ -568,6 +567,13 @@ mca_part_persist_parrived(size_t min_part,
     int _flag = false;
     mca_part_persist_request_t *req = (mca_part_persist_request_t *)request;
 
+    // An inactive (never-started) precv request has no flags array yet.
+    // MPI-5.0 sec 4.2.2 (p.119): an inactive request is trivially arrived.
+    if(NULL == req->flags && OMPI_REQUEST_INACTIVE == request->req_state) {
+        *flag = 1;
+        return err;
+    }
+
     if(0 != req->flags) {
         _flag = 1;
         if(req->req_parts == req->real_parts) {
diff --git a/ompi/mca/pml/cm/pml_cm_recvreq.h b/ompi/mca/pml/cm/pml_cm_recvreq.h
index 1c1cca4616d..250305e6864 100644
--- a/ompi/mca/pml/cm/pml_cm_recvreq.h
+++ b/ompi/mca/pml/cm/pml_cm_recvreq.h
@@ -234,7 +234,7 @@ do {                                                                    \
 do {                                                                    \
     /* init/re-init the request */                                      \
     request->req_base.req_pml_complete = false;                         \
-    request->req_base.req_ompi.req_complete = false;                    \
+    request->req_base.req_ompi.req_complete = REQUEST_PENDING;          \
     request->req_base.req_ompi.req_state = OMPI_REQUEST_ACTIVE;         \
                                                                         \
     /* always set the req_status.MPI_TAG to ANY_TAG before starting the \
@@ -256,7 +256,7 @@ do {                                                                    \
 do {                                                                    \
     /* init/re-init the request */                                      \
     request->req_base.req_pml_complete = false;                         \
-    request->req_base.req_ompi.req_complete = false;                    \
+    request->req_base.req_ompi.req_complete = REQUEST_PENDING;          \
     request->req_base.req_ompi.req_state = OMPI_REQUEST_ACTIVE;         \
                                                                         \
     /* always set the req_status.MPI_TAG to ANY_TAG before starting the \
@@ -278,7 +278,7 @@ do {                                                                    \
 /*     opal_output(0, "posting hvy request %d\n", request);                */ \
     /* init/re-init the request */                                      \
     request->req_base.req_pml_complete = false;                         \
-    request->req_base.req_ompi.req_complete = false;                    \
+    request->req_base.req_ompi.req_complete = REQUEST_PENDING;          \
     request->req_base.req_ompi.req_state = OMPI_REQUEST_ACTIVE;         \
                                                                         \
     /* always set the req_status.MPI_TAG to ANY_TAG before starting the \
diff --git a/ompi/mca/pml/ob1/pml_ob1.c b/ompi/mca/pml/ob1/pml_ob1.c
index e0516d16fe0..a08f5e7398c 100644
--- a/ompi/mca/pml/ob1/pml_ob1.c
+++ b/ompi/mca/pml/ob1/pml_ob1.c
@@ -27,6 +27,7 @@
  *                         reserved.
  * Copyright (c) 2022      IBM Corporation. All rights reserved
  * Copyright (c) 2023      Jeffrey M. Squyres.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University. All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -721,6 +722,11 @@ int mca_pml_ob1_dump(struct ompi_communicator_t* comm, int verbose)
         /* dump all btls used for eager messages */
         for( n = 0; n < ep->btl_eager.arr_size; n++ ) {
             mca_bml_base_btl_t* bml_btl = &ep->btl_eager.bml_btls[n];
+            if (bml_btl->btl->btl_dump == NULL) {
+                opal_output(0, "BTL %s does not provide dump callback\n",
+                            bml_btl->btl->btl_component->btl_version.mca_component_name);
+                continue;
+            }
             bml_btl->btl->btl_dump(bml_btl->btl, bml_btl->btl_endpoint, verbose);
         }
     }
diff --git a/ompi/mca/pml/ob1/pml_ob1.h b/ompi/mca/pml/ob1/pml_ob1.h
index a0091793ab4..29a57d02f51 100644
--- a/ompi/mca/pml/ob1/pml_ob1.h
+++ b/ompi/mca/pml/ob1/pml_ob1.h
@@ -255,6 +255,12 @@ do {                                                            \
         (opal_free_list_item_t*)pckt);                          \
 } while(0)
 
+/**
+ * A thread-safe function that should be called every time we need the OB1
+ * progress to be turned (or kept) on.
+ */
+int mca_pml_ob1_enable_progress(int32_t count);
+
 static inline void mca_pml_ob1_add_to_pending (ompi_proc_t *proc, mca_bml_base_btl_t *bml_btl,
                                                int order, mca_pml_ob1_hdr_t *hdr, size_t hdr_size)
 {
@@ -270,6 +276,10 @@ static inline void mca_pml_ob1_add_to_pending (ompi_proc_t *proc, mca_bml_base_b
     OPAL_THREAD_SCOPED_LOCK(&mca_pml_ob1.lock, {
             opal_list_append(&mca_pml_ob1.pckt_pending, &pckt->super.super);
         });
+    /* Drive mca_pml_ob1_progress() so the queue is retried from opal_progress()
+     * even if no further BTL completion fires to call
+     * MCA_PML_OB1_PROGRESS_PENDING. */
+    mca_pml_ob1_enable_progress(1);
 }
 
 #define OB1_MATCHING_LOCK(lock)                                  \
@@ -411,12 +421,6 @@ mca_pml_ob1_calc_weighted_length( mca_pml_ob1_com_btl_t *btls, int num_btls, siz
     btls[0].length += length_left;
 }
 
-/**
- * A thread-safe function that should be called every time we need the OB1
- * progress to be turned (or kept) on.
- */
-int mca_pml_ob1_enable_progress(int32_t count);
-
 int mca_pml_ob1_send_control_any (ompi_proc_t *proc, int order, mca_pml_ob1_hdr_t *hdr, size_t hdr_size,
                                   bool add_to_pending);
 int mca_pml_ob1_send_control_btl (mca_bml_base_btl_t *bml_btl, int order, mca_pml_ob1_hdr_t *hdr, size_t hdr_size,
diff --git a/ompi/mca/pml/ob1/pml_ob1_irecv.c b/ompi/mca/pml/ob1/pml_ob1_irecv.c
index 4ccb8ea00f2..7c2e89c2fb8 100644
--- a/ompi/mca/pml/ob1/pml_ob1_irecv.c
+++ b/ompi/mca/pml/ob1/pml_ob1_irecv.c
@@ -233,6 +233,9 @@ mca_pml_ob1_imrecv( void *buf,
     recvreq->req_rdma_idx = 0;
     recvreq->req_pending = false;
     recvreq->req_ack_sent = false;
+    recvreq->req_match_received = false;
+    /* release: pair with rmb in recv_request_pml_complete_check */
+    opal_atomic_wmb();
 
     MCA_PML_BASE_RECV_START(&recvreq->req_recv);
 
@@ -325,6 +328,10 @@ mca_pml_ob1_mrecv( void *buf,
     recvreq->req_rdma_cnt = 0;
     recvreq->req_rdma_idx = 0;
     recvreq->req_pending = false;
+    recvreq->req_ack_sent = false;
+    recvreq->req_match_received = false;
+    /* release: pair with rmb in recv_request_pml_complete_check */
+    opal_atomic_wmb();
 
     MCA_PML_BASE_RECV_START(&recvreq->req_recv);
 
diff --git a/ompi/mca/pml/ob1/pml_ob1_progress.c b/ompi/mca/pml/ob1/pml_ob1_progress.c
index 930d5b7311e..935d5bf1357 100644
--- a/ompi/mca/pml/ob1/pml_ob1_progress.c
+++ b/ompi/mca/pml/ob1/pml_ob1_progress.c
@@ -71,6 +71,21 @@ int mca_pml_ob1_progress(void)
 
     completed_requests += mca_pml_ob1_process_pending_accelerator_async_copies();
 
+    /* Drain the FIN/ACK control-packet retry queue. It is otherwise drained
+     * only as a side effect of BTL completion callbacks (see
+     * MCA_PML_OB1_PROGRESS_PENDING). If the BTL goes idle while packets are
+     * still queued -- e.g. the tail of an incast where btl_sendi() repeatedly
+     * returned OPAL_ERR_OUT_OF_RESOURCE -- no further completion fires, the
+     * queue is never revisited, and every peer waiting on those FINs hangs
+     * forever. Retrying it here, driven by mca_pml_ob1_progress_needed (which
+     * mca_pml_ob1_add_to_pending() bumps via mca_pml_ob1_enable_progress()),
+     * guarantees the queue makes progress even with no BTL traffic in flight. */
+    if( opal_list_get_size(&mca_pml_ob1.pckt_pending) ) {
+        int pckt_before = (int) opal_list_get_size(&mca_pml_ob1.pckt_pending);
+        mca_pml_ob1_process_pending_packets(NULL);
+        completed_requests += pckt_before - (int) opal_list_get_size(&mca_pml_ob1.pckt_pending);
+    }
+
     for( i = 0; i < queue_length; i++ ) {
         mca_pml_ob1_send_pending_t pending_type = MCA_PML_OB1_SEND_PENDING_NONE;
         mca_pml_ob1_send_request_t* sendreq;
diff --git a/ompi/mca/pml/ob1/pml_ob1_recvfrag.c b/ompi/mca/pml/ob1/pml_ob1_recvfrag.c
index 8e1d4d2e0cf..3445c45188a 100644
--- a/ompi/mca/pml/ob1/pml_ob1_recvfrag.c
+++ b/ompi/mca/pml/ob1/pml_ob1_recvfrag.c
@@ -768,6 +768,10 @@ void mca_pml_ob1_recv_frag_callback_ack (mca_btl_base_module_t *btl,
         sendreq->req_send.req_base.req_convertor.stream = stream;
     }
 
+    /* ensure all prior stores (copy_in_out, rdma_frag, throttle_sends,
+     * req_state, accelerator flags) are visible before complete_check
+     * may recycle the request */
+    opal_atomic_wmb();
     if (send_request_pml_complete_check(sendreq) == false)
         mca_pml_ob1_send_request_schedule(sendreq);
 }
diff --git a/ompi/mca/pml/ob1/pml_ob1_recvreq.c b/ompi/mca/pml/ob1/pml_ob1_recvreq.c
index a6a2866f2a2..74c8113ff7a 100644
--- a/ompi/mca/pml/ob1/pml_ob1_recvreq.c
+++ b/ompi/mca/pml/ob1/pml_ob1_recvreq.c
@@ -228,6 +228,9 @@ static void mca_pml_ob1_put_completion (mca_pml_ob1_rdma_frag_t *frag, int64_t r
 
     if (OPAL_LIKELY(0 < rdma_size)) {
 
+        /* ensure pipeline_depth and frag cleanup are visible before
+         * bytes_received update that complete_check observes */
+        opal_atomic_wmb();
         /* check completion status */
         OPAL_THREAD_ADD_FETCH_SIZE_T(&recvreq->req_bytes_received, rdma_size);
         SPC_USER_OR_MPI(recvreq->req_recv.req_base.req_ompi.req_status.MPI_TAG, (ompi_spc_value_t)rdma_size,
@@ -443,6 +446,9 @@ static void mca_pml_ob1_rget_completion (mca_btl_base_module_t* btl, struct mca_
         MCA_PML_OB1_RDMA_FRAG_RETURN(frag);
     }
 
+    /* ensure all prior stores (bytes_received, error status, frag cleanup)
+     * are visible before complete_check may recycle the request */
+    opal_atomic_wmb();
     recv_request_pml_complete_check(recvreq);
 
     MCA_PML_OB1_PROGRESS_PENDING(bml_btl);
@@ -596,6 +602,9 @@ void mca_pml_ob1_recv_request_progress_frag( mca_pml_ob1_recv_request_t* recvreq
                                recvreq->req_recv.req_base.req_datatype);
                );
 
+    /* ensure unpack stores are visible before bytes_received update
+     * that complete_check observes */
+    opal_atomic_wmb();
     OPAL_THREAD_ADD_FETCH_SIZE_T(&recvreq->req_bytes_received, bytes_received);
     SPC_USER_OR_MPI(recvreq->req_recv.req_base.req_ompi.req_status.MPI_TAG, (ompi_spc_value_t)bytes_received,
                     OMPI_SPC_BYTES_RECEIVED_USER, OMPI_SPC_BYTES_RECEIVED_MPI);
@@ -674,6 +683,9 @@ void mca_pml_ob1_recv_request_frag_copy_finished( mca_btl_base_module_t* btl,
      * known that the data has been copied out of the descriptor. */
     des->des_cbfunc(NULL, NULL, des, 0);
 
+    /* ensure copy and descriptor cleanup are visible before
+     * bytes_received update that complete_check observes */
+    opal_atomic_wmb();
     OPAL_THREAD_ADD_FETCH_SIZE_T(&recvreq->req_bytes_received, bytes_received);
     SPC_USER_OR_MPI(recvreq->req_recv.req_base.req_ompi.req_status.MPI_TAG, (ompi_spc_value_t)bytes_received,
                     OMPI_SPC_BYTES_RECEIVED_USER, OMPI_SPC_BYTES_RECEIVED_MPI);
@@ -887,6 +899,9 @@ void mca_pml_ob1_recv_request_progress_rndv( mca_pml_ob1_recv_request_t* recvreq
         SPC_USER_OR_MPI(recvreq->req_recv.req_base.req_ompi.req_status.MPI_TAG, (ompi_spc_value_t)bytes_received,
                         OMPI_SPC_BYTES_RECEIVED_USER, OMPI_SPC_BYTES_RECEIVED_MPI);
     }
+    /* ensure all prior stores (unpack, match, bytes_received) are visible
+     * before complete_check may recycle the request */
+    opal_atomic_wmb();
     /* check completion status */
     if(recv_request_pml_complete_check(recvreq) == false &&
        recvreq->req_rdma_offset < recvreq->req_send_offset) {
diff --git a/ompi/mca/pml/ob1/pml_ob1_recvreq.h b/ompi/mca/pml/ob1/pml_ob1_recvreq.h
index a266e3388bb..558975c2597 100644
--- a/ompi/mca/pml/ob1/pml_ob1_recvreq.h
+++ b/ompi/mca/pml/ob1/pml_ob1_recvreq.h
@@ -65,11 +65,14 @@ OBJ_CLASS_DECLARATION(mca_pml_ob1_recv_request_t);
 
 static inline bool lock_recv_request(mca_pml_ob1_recv_request_t *recvreq)
 {
-        return OPAL_THREAD_ADD_FETCH32(&recvreq->req_lock,  1) == 1;
+        bool ret = OPAL_THREAD_ADD_FETCH32(&recvreq->req_lock,  1) == 1;
+        opal_atomic_rmb();
+        return ret;
 }
 
 static inline bool unlock_recv_request(mca_pml_ob1_recv_request_t *recvreq)
 {
+        opal_atomic_wmb();
         return OPAL_THREAD_ADD_FETCH32(&recvreq->req_lock, -1) == 0;
 }
 
@@ -247,9 +250,10 @@ static inline void recv_req_matched(mca_pml_ob1_recv_request_t *req,
 {
     req->req_recv.req_base.req_ompi.req_status.MPI_SOURCE = hdr->hdr_src;
     req->req_recv.req_base.req_ompi.req_status.MPI_TAG = hdr->hdr_tag;
-    req->req_match_received = true;
-
+    /* ensure MPI_SOURCE, MPI_TAG, and req_bytes_packed (set by caller)
+     * are visible before req_match_received signals complete_check */
     opal_atomic_wmb();
+    req->req_match_received = true;
 
     if(req->req_recv.req_bytes_packed > 0) {
 #if OPAL_ENABLE_HETEROGENEOUS_SUPPORT
diff --git a/ompi/mca/pml/ob1/pml_ob1_sendreq.c b/ompi/mca/pml/ob1/pml_ob1_sendreq.c
index 0dd246917c0..f40dff6ce89 100644
--- a/ompi/mca/pml/ob1/pml_ob1_sendreq.c
+++ b/ompi/mca/pml/ob1/pml_ob1_sendreq.c
@@ -261,6 +261,10 @@ mca_pml_ob1_rndv_completion_request( mca_bml_base_btl_t* bml_btl,
     SPC_USER_OR_MPI(sendreq->req_send.req_base.req_ompi.req_status.MPI_TAG, (ompi_spc_value_t)req_bytes_delivered,
                     OMPI_SPC_BYTES_SENT_USER, OMPI_SPC_BYTES_SENT_MPI);
 
+    /* ensure bytes_delivered is visible before req_state update, so that
+     * another thread's complete_check sees consistent state */
+    opal_atomic_wmb();
+
     /* advance the request */
     OPAL_THREAD_ADD_FETCH32(&sendreq->req_state, -1);
 
@@ -360,6 +364,9 @@ mca_pml_ob1_rget_completion (mca_pml_ob1_rdma_frag_t *frag, int64_t rdma_length)
         MCA_PML_OB1_RDMA_FRAG_RETURN(frag);
     }
 
+    /* ensure all prior stores (bytes_delivered, rdma_frag, error status)
+     * are visible before complete_check may recycle the request */
+    opal_atomic_wmb();
     send_request_pml_complete_check(sendreq);
 
     if( OPAL_LIKELY(0 < rdma_length) ) {
@@ -440,6 +447,9 @@ mca_pml_ob1_frag_completion( mca_btl_base_module_t* btl,
                                                                        sizeof(mca_pml_ob1_frag_hdr_t));
     }
 
+    /* ensure prior non-atomic stores (e.g. error status) are visible
+     * before atomic updates that complete_check will observe */
+    opal_atomic_wmb();
     OPAL_THREAD_ADD_FETCH32(&sendreq->req_pipeline_depth, -1);
     OPAL_THREAD_ADD_FETCH_SIZE_T(&sendreq->req_bytes_delivered, req_bytes_delivered);
     SPC_USER_OR_MPI(sendreq->req_send.req_base.req_ompi.req_status.MPI_TAG, (ompi_spc_value_t)req_bytes_delivered,
@@ -1318,11 +1328,13 @@ static void mca_pml_ob1_put_completion (mca_btl_base_module_t* btl, struct mca_b
 
     /* check completion status */
     if( OPAL_UNLIKELY(OMPI_SUCCESS == status) ) {
-        /* TODO -- read ordering */
         mca_pml_ob1_send_fin (sendreq->req_send.req_base.req_proc, bml_btl,
                               frag->rdma_hdr.hdr_rdma.hdr_frag, frag->rdma_length,
                               0, 0);
 
+        /* ensure send_fin stores are visible before bytes_delivered
+         * update that complete_check observes */
+        opal_atomic_wmb();
         /* check for request completion */
         OPAL_THREAD_ADD_FETCH_SIZE_T(&sendreq->req_bytes_delivered, frag->rdma_length);
         SPC_USER_OR_MPI(sendreq->req_send.req_base.req_ompi.req_status.MPI_TAG, (ompi_spc_value_t)frag->rdma_length,
@@ -1411,6 +1423,7 @@ void mca_pml_ob1_send_request_put (mca_pml_ob1_send_request_t *sendreq,
     mca_pml_ob1_rdma_frag_t* frag;
 
     if(hdr->hdr_common.hdr_flags & MCA_PML_OB1_HDR_TYPE_ACK) {
+        opal_atomic_wmb();  /* ensure prior stores visible before req_state update */
         OPAL_THREAD_ADD_FETCH32(&sendreq->req_state, -1);
     }
 
@@ -1434,6 +1447,10 @@ void mca_pml_ob1_send_request_put (mca_pml_ob1_send_request_t *sendreq,
         /* rget fallback on put */
         frag = sendreq->rdma_frag;
         sendreq->rdma_frag = NULL;
+        /* ensure rdma_frag = NULL is visible before req_state signals
+         * completion — plain store of 0 is the completion trigger that
+         * complete_check observes */
+        opal_atomic_wmb();
         sendreq->req_state = 0;
     }
 
diff --git a/ompi/mca/pml/ob1/pml_ob1_sendreq.h b/ompi/mca/pml/ob1/pml_ob1_sendreq.h
index e9946e90528..6d2a8b09d13 100644
--- a/ompi/mca/pml/ob1/pml_ob1_sendreq.h
+++ b/ompi/mca/pml/ob1/pml_ob1_sendreq.h
@@ -79,11 +79,14 @@ OBJ_CLASS_DECLARATION(mca_pml_ob1_send_range_t);
 
 static inline bool lock_send_request(mca_pml_ob1_send_request_t *sendreq)
 {
-    return OPAL_THREAD_ADD_FETCH32(&sendreq->req_lock,  1) == 1;
+    bool ret = OPAL_THREAD_ADD_FETCH32(&sendreq->req_lock,  1) == 1;
+    opal_atomic_rmb();
+    return ret;
 }
 
 static inline bool unlock_send_request(mca_pml_ob1_send_request_t *sendreq)
 {
+    opal_atomic_wmb();
     return OPAL_THREAD_ADD_FETCH32(&sendreq->req_lock, -1) == 0;
 }
 
@@ -468,6 +471,17 @@ mca_pml_ob1_send_request_start_seq (mca_pml_ob1_send_request_t* sendreq, mca_bml
     sendreq->req_pending = MCA_PML_OB1_SEND_PENDING_NONE;
     sendreq->req_send.req_base.req_sequence = seqn;
 
+    /* drain any stale send ranges left from a previous lifecycle;
+     * not protected by a lock as the sendreq is owned exclusively
+     * by the current thread at this point in the lifecycle. */
+    if (OPAL_UNLIKELY(!opal_list_is_empty(&sendreq->req_send_ranges))) {
+        opal_list_item_t *item;
+        OPAL_OUTPUT_VERBOSE((1, mca_pml_ob1_output, "stale send ranges on reused sendreq"));
+        while (NULL != (item = opal_list_remove_first(&sendreq->req_send_ranges))) {
+            opal_free_list_return(&mca_pml_ob1.send_ranges, (opal_free_list_item_t *)item);
+        }
+    }
+
     MCA_PML_BASE_SEND_START( &sendreq->req_send );
 
     for(size_t i = 0; i < mca_bml_base_btl_array_get_size(&endpoint->btl_eager); i++) {
diff --git a/ompi/mca/pml/ubcl/configure.m4 b/ompi/mca/pml/ubcl/configure.m4
index 262de492c19..ac3b17efb6d 100644
--- a/ompi/mca/pml/ubcl/configure.m4
+++ b/ompi/mca/pml/ubcl/configure.m4
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024 Bull SAS.  All rights reserved.
+# Copyright (c) 2024-2026 Bull SAS.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -19,6 +19,13 @@ AC_DEFUN([MCA_ompi_pml_ubcl_CONFIG], [
                    [pml_ubcl_happy="yes"],
                    [pml_ubcl_happy="no"])
 
+    # See ompi/mca/common/ubcl/configure.m4 comment explaining why UBCL linking
+    # flags are removed only in dynamic mode
+    AS_IF([test "$compile_mode" = "dso"],
+          [pml_ubcl_LDFLAGS=""],
+          # Static mode should work, but Bull provides support only for dynamic components
+          [AC_MSG_WARN([Only DSO mode of pml/ubcl is tested (see --enable-mca-dso)])])
+
     AC_REQUIRE([MCA_ompi_common_ubcl_CONFIG])
     AC_REQUIRE([MCA_opal_common_ubcl_CONFIG])
 
diff --git a/ompi/mca/pml/ubcl/pml_ubcl_iprobe.c b/ompi/mca/pml/ubcl/pml_ubcl_iprobe.c
index 6b6dbad0cee..b8e87fe6813 100644
--- a/ompi/mca/pml/ubcl/pml_ubcl_iprobe.c
+++ b/ompi/mca/pml/ubcl/pml_ubcl_iprobe.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2019-2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2019-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -32,6 +32,7 @@ int mca_pml_ubcl_iprobe(int src, int tag, struct ompi_communicator_t *comm,
     OPAL_OUTPUT_VERBOSE((75, mca_pml_ubcl_component.output,
                         "UBCL_MODULE_IPROBE\n"));
     ubcl_status_t ubcl_status;
+    ubcl_error_t err;
     uint64_t cid;
     uint64_t rank;
 
@@ -45,10 +46,13 @@ int mca_pml_ubcl_iprobe(int src, int tag, struct ompi_communicator_t *comm,
     }
 
     cid = ompi_comm_get_local_cid(comm);
-    ubcl_cid_t ubcl_cid= mca_pml_ubcl_compute_ubcl_cid(tag, cid);
+    ubcl_cid_t ubcl_cid = mca_pml_ubcl_compute_ubcl_cid(tag, cid);
 
     /* Call the UBCL api for iprobe */
-    ubcl_iprobe(rank, tag, ubcl_cid, matched, &ubcl_status);
+    err = ubcl_iprobe(rank, tag, ubcl_cid, matched, &ubcl_status);
+    if (UBCL_SUCCESS != err) {
+        return ubcl_error_to_ompi(err);
+    }
     if (*matched) {
         mca_common_ubcl_status_to_ompi(status, ubcl_status, comm, src);
     }
@@ -78,6 +82,7 @@ int mca_pml_ubcl_improbe(int src, int tag, struct ompi_communicator_t *comm,
     OPAL_OUTPUT_VERBOSE((75, mca_pml_ubcl_component.output,
                         "UBCL_MODULE_IMPROBE\n"));
     ubcl_status_t ubcl_status;
+    ubcl_error_t err;
     uint64_t rank;
     uint64_t cid;
     if (OMPI_ANY_SOURCE == src) {
@@ -95,7 +100,10 @@ int mca_pml_ubcl_improbe(int src, int tag, struct ompi_communicator_t *comm,
     ubcl_message_t *ubcl_message;
 
     /* Call the UBCL api for improbe */
-    ubcl_improbe(rank, tag, ubcl_cid, matched, &ubcl_message, &ubcl_status);
+    err = ubcl_improbe(rank, tag, ubcl_cid, matched, &ubcl_message, &ubcl_status);
+    if (UBCL_SUCCESS != err) {
+        return ubcl_error_to_ompi(err);
+    }
     if (*matched) {
         mca_common_ubcl_status_to_ompi(status, ubcl_status, comm, src);
         *message = ompi_message_alloc();
diff --git a/ompi/mca/pml/ubcl/pml_ubcl_irecv.c b/ompi/mca/pml/ubcl/pml_ubcl_irecv.c
index 9ea74d9e428..0f46cec2f4d 100644
--- a/ompi/mca/pml/ubcl/pml_ubcl_irecv.c
+++ b/ompi/mca/pml/ubcl/pml_ubcl_irecv.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2019-2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2019-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -91,17 +91,16 @@ void mca_pml_ubcl_irecv_start(struct ompi_request_t **request)
                                               mca_pml_ubcl_request_t, ompi_req);
     void *output_buf = (void *) req->buf;
 
-    ubcl_memory_descriptor_t rbuf_md;
     ubcl_error_t err = 0;
     size_t size;
 
     /* Init UBCL MD */
-    err = ubcl_memory_descriptor_init(&rbuf_md);
+    err = ubcl_memory_descriptor_init(&req->md);
     if (UBCL_SUCCESS != err) {
         mca_pml_ubcl_error(ubcl_error_to_ompi(err), "Failed to initialize ubcl MD");
     }
     if (pml_ubcl_request_is_cuda_buf(req)) {
-        err = ubcl_memory_descriptor_set_properties(UBCL_BUF_IS_CUDA, &rbuf_md);
+        err = ubcl_memory_descriptor_set_properties(UBCL_BUF_IS_CUDA, &req->md);
         if (UBCL_SUCCESS != err) {
             mca_pml_ubcl_error(ubcl_error_to_ompi(err),
                                "Failed to set MD properties, got error: %d", err);
@@ -113,7 +112,7 @@ void mca_pml_ubcl_irecv_start(struct ompi_request_t **request)
         ompi_datatype_type_size(req->datatype, &size);
         size *= req->count;
 
-        err = ubcl_memory_descriptor_build_contiguous(output_buf, size, &rbuf_md);
+        err = ubcl_memory_descriptor_build_contiguous(output_buf, size, &req->md);
         if (UBCL_SUCCESS != err) {
             mca_pml_ubcl_error(ubcl_error_to_ompi(err),
                                "Failed to build memory descriptor for output buffer");
@@ -121,12 +120,9 @@ void mca_pml_ubcl_irecv_start(struct ompi_request_t **request)
     }
 
     /* Always build a custom MD representation so that we have a fallback */
-    err = ubcl_memory_descriptor_build_custom((void *) &req->convertor,
-                                              pml_ubcl_datatype_pack,
-                                              pml_ubcl_datatype_unpack,
-                                              pml_ubcl_datatype_mem_size,
-                                              pml_ubcl_datatype_finish,
-                                              &rbuf_md);
+    err = ubcl_memory_descriptor_build_custom((void *) &req->convertor, pml_ubcl_datatype_pack,
+                                              pml_ubcl_datatype_unpack, pml_ubcl_datatype_mem_size,
+                                              pml_ubcl_datatype_finish, &req->md);
     if (UBCL_SUCCESS != err) {
         mca_pml_ubcl_error(ubcl_error_to_ompi(err),
                            "Failed to build custom memory descriptor for input buffer");
@@ -136,9 +132,8 @@ void mca_pml_ubcl_irecv_start(struct ompi_request_t **request)
     MCA_PML_UBCL_REQUEST_ACTIVATE(req);
 
     if (req->message != NULL) {
-        err = ubcl_imrecv(rbuf_md, (ubcl_message_t **) &req->message,
-                          (ubcl_completion_callback_fct) &ubcl_request_recv_complete_cb,
-                          *request);
+        err = ubcl_imrecv(req->md, (ubcl_message_t **) &req->message,
+                          (ubcl_completion_callback_fct) ubcl_request_recv_complete_cb, *request);
     } else {
         uint64_t rank;
         uint64_t cid;
@@ -158,9 +153,9 @@ void mca_pml_ubcl_irecv_start(struct ompi_request_t **request)
 
         OPAL_OUTPUT_VERBOSE(
                 (50, mca_pml_ubcl_component.output, "PML/UBCL IRECV: recv from rank=%zu\n", rank));
-        err = ubcl_irecv(rbuf_md, tag, ubcl_cid, rank,
-                         (ubcl_completion_callback_fct) &ubcl_request_recv_complete_cb,
-                         *request, &req->ubcl_operation_handle);
+        err = ubcl_irecv(req->md, tag, ubcl_cid, rank,
+                         (ubcl_completion_callback_fct) &ubcl_request_recv_complete_cb, *request,
+                         &req->ubcl_operation_handle);
     }
 
     if (UBCL_ERROR == err) {
diff --git a/ompi/mca/pml/ubcl/pml_ubcl_isend.c b/ompi/mca/pml/ubcl/pml_ubcl_isend.c
index 3bd19f0852c..8dcfbc8ffe4 100644
--- a/ompi/mca/pml/ubcl/pml_ubcl_isend.c
+++ b/ompi/mca/pml/ubcl/pml_ubcl_isend.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2019-2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2019-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -106,7 +106,6 @@ void mca_pml_ubcl_isend_start(struct ompi_request_t **request)
 
     char *input_buf = NULL;
     mca_common_ubcl_endpoint_t *endpoint = NULL;
-    ubcl_memory_descriptor_t sbuf_md;
     ubcl_error_t err = 0;
     ubcl_send_mode_t send_mode;
     uint64_t cid;
@@ -127,12 +126,12 @@ void mca_pml_ubcl_isend_start(struct ompi_request_t **request)
     endpoint = (mca_common_ubcl_endpoint_t *) req->proc->proc_endpoints[OMPI_PROC_ENDPOINT_TAG_PML];
 
     /* Init UBCL MD */
-    err = ubcl_memory_descriptor_init(&sbuf_md);
+    err = ubcl_memory_descriptor_init(&req->md);
     if (UBCL_SUCCESS != err) {
         mca_pml_ubcl_error(ubcl_error_to_ompi(err), "Failed to initialize ubcl MD");
     }
     if (pml_ubcl_request_is_cuda_buf(req)) {
-        err = ubcl_memory_descriptor_set_properties(UBCL_BUF_IS_CUDA, &sbuf_md);
+        err = ubcl_memory_descriptor_set_properties(UBCL_BUF_IS_CUDA, &req->md);
         if (UBCL_SUCCESS != err) {
             mca_pml_ubcl_error(ubcl_error_to_ompi(err),
                                "Failed to set MD properties, got error: %d", err);
@@ -143,7 +142,7 @@ void mca_pml_ubcl_isend_start(struct ompi_request_t **request)
     if (! MCA_PML_UBCL_REQUEST_NEED_XPACK(req)) {
         ptrdiff_t gap = 0;
         size_t span = opal_datatype_span(&req->datatype->super, req->count, &gap);
-        err = ubcl_memory_descriptor_build_contiguous(input_buf+gap, span, &sbuf_md);
+        err = ubcl_memory_descriptor_build_contiguous(input_buf + gap, span, &req->md);
         if (UBCL_SUCCESS != err) {
             mca_pml_ubcl_error(ubcl_error_to_ompi(err),
                                "Failed to build contiguous memory descriptor for input buffer");
@@ -151,11 +150,9 @@ void mca_pml_ubcl_isend_start(struct ompi_request_t **request)
     }
 
     /* Always build a custom MD representation so that we have a fallback */
-    err = ubcl_memory_descriptor_build_custom((void *) &req->convertor,
-                                              pml_ubcl_datatype_pack,
-                                              pml_ubcl_datatype_unpack,
-                                              pml_ubcl_datatype_mem_size,
-                                              pml_ubcl_datatype_finish, &sbuf_md);
+    err = ubcl_memory_descriptor_build_custom((void *) &req->convertor, pml_ubcl_datatype_pack,
+                                              pml_ubcl_datatype_unpack, pml_ubcl_datatype_mem_size,
+                                              pml_ubcl_datatype_finish, &req->md);
     if (UBCL_SUCCESS != err) {
         mca_pml_ubcl_error(ubcl_error_to_ompi(err),
                            "Failed to build custom memory descriptor for input buffer");
@@ -171,9 +168,9 @@ void mca_pml_ubcl_isend_start(struct ompi_request_t **request)
     OPAL_OUTPUT_VERBOSE(
         (50, mca_pml_ubcl_component.output, "PML/UBCL ISEND: sending to rank=%zu\n", endpoint->rank));
 
-    err = ubcl_isend(sbuf_md, tag, ubcl_cid, endpoint->rank, send_mode,
-                     (ubcl_completion_callback_fct) &ubcl_request_send_complete_cb,
-                     *request, &req->ubcl_operation_handle);
+    err = ubcl_isend(req->md, tag, ubcl_cid, endpoint->rank, send_mode,
+                     (ubcl_completion_callback_fct) ubcl_request_send_complete_cb, *request,
+                     &req->ubcl_operation_handle);
     if (UBCL_ERROR == err) {
         mca_pml_ubcl_error(ubcl_error_to_ompi(err), "Failed to send data");
     }
diff --git a/ompi/mca/pml/ubcl/pml_ubcl_request.c b/ompi/mca/pml/ubcl/pml_ubcl_request.c
index b5a206f504c..85699e3f803 100644
--- a/ompi/mca/pml/ubcl/pml_ubcl_request.c
+++ b/ompi/mca/pml/ubcl/pml_ubcl_request.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2019-2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2019-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -216,7 +216,6 @@ int mca_pml_ubcl_request_complete_cb(struct ompi_request_t *request)
     return mca_pml_ubcl_request_complete(request);
 }
 
-/* TODO: Get a pointer to status and not a cpy ? */
 void ubcl_request_send_complete_cb(ubcl_status_t status, void *cb_data)
 {
     if (UBCL_SUCCESS != status.status) {
@@ -232,7 +231,9 @@ void ubcl_request_send_complete_cb(ubcl_status_t status, void *cb_data)
     /* This lock cannot be removed, even in thread single mode */
     opal_atomic_lock(&req->req_lock);
     req->completed = 1;
+    ubcl_memory_descriptor_destruct(&req->md);
     opal_atomic_unlock(&req->req_lock);
+
     if (req->is_buffered) {
         mca_pml_base_bsend_request_free(req->comm, (void*)req->buf);
         /* Bsend started completed, but could not be freed, now that UBCL is
@@ -280,6 +281,7 @@ void ubcl_request_recv_complete_cb(ubcl_status_t status, void *cb_data)
     /* This lock cannot be removed, even in thread single mode */
     opal_atomic_lock(&req->req_lock);
     req->completed = 1;
+    ubcl_memory_descriptor_destruct(&req->md);
     opal_atomic_unlock(&req->req_lock);
     ompi_request_complete(&(req->ompi_req), true);
 
diff --git a/ompi/mca/pml/ubcl/pml_ubcl_request.h b/ompi/mca/pml/ubcl/pml_ubcl_request.h
index d47fa598af8..256f276e39c 100644
--- a/ompi/mca/pml/ubcl/pml_ubcl_request.h
+++ b/ompi/mca/pml/ubcl/pml_ubcl_request.h
@@ -1,6 +1,6 @@
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
- * Copyright (c) 2019-2025 Bull SAS.  All rights reserved.
+ * Copyright (c) 2019-2026 Bull SAS.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -85,6 +85,7 @@ struct mca_pml_ubcl_request_t {
     struct ompi_communicator_t *comm; /**< Communicator */
     struct ompi_proc_t *proc;         /**< Remote ompi proc */
     opal_convertor_t convertor;       /**< Data convertor */
+    ubcl_memory_descriptor_t md;
     ompi_request_complete_fn_t saved_complete_cb; /**< Saved callback from another component (e.g OSC pt2pt) */
     void *saved_complete_cb_data; /**< Saved callback data from another component (e.g OSC pt2pt) */
 
diff --git a/ompi/mca/sharedfp/individual/sharedfp_individual.c b/ompi/mca/sharedfp/individual/sharedfp_individual.c
index d6e06dd450e..35810b485c0 100644
--- a/ompi/mca/sharedfp/individual/sharedfp_individual.c
+++ b/ompi/mca/sharedfp/individual/sharedfp_individual.c
@@ -15,6 +15,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -30,6 +31,7 @@
 
 #include "ompi_config.h"
 #include "mpi.h"
+#include "ompi/file/file.h"
 #include "ompi/mca/sharedfp/sharedfp.h"
 #include "ompi/mca/sharedfp/base/base.h"
 #include "ompi/mca/sharedfp/individual/sharedfp_individual.h"
@@ -64,6 +66,38 @@ static mca_sharedfp_base_module_2_0_0_t individual =  {
  * *******************************************************************
  */
 
+static const char *mca_sharedfp_individual_relaxed_ordering_cb(opal_infosubscriber_t *object,
+                                                               const char *key,
+                                                               const char *value)
+{
+    ompi_file_t *file;
+    mca_common_ompio_data_t *data;
+    ompio_file_t *fh;
+
+    if (NULL == object || NULL == key || NULL == value || '\0' == value[0]) {
+        return NULL;
+    }
+
+    file = (ompi_file_t *) object;
+    data = (mca_common_ompio_data_t *) file->f_io_selected_data;
+    if (NULL == data) {
+        return NULL;
+    }
+    fh = &data->ompio_fh;
+
+    /*
+     * sharedfp selection queries every candidate component.  This callback
+     * must accept the hint while selection is still in progress because the
+     * hint raises individual's priority, but once a sharedfp module is known
+     * the hint is public only if this component actually won selection.
+     */
+    if (NULL != fh->f_sharedfp && &individual != fh->f_sharedfp) {
+        return NULL;
+    }
+
+    return value;
+}
+
 int mca_sharedfp_individual_component_init_query(bool enable_progress_threads,
                                             bool enable_mpi_threads)
 {
@@ -79,6 +113,7 @@ struct mca_sharedfp_base_module_2_0_0_t * mca_sharedfp_individual_component_file
     bool relaxed_order_flag=false;
     opal_info_t *info;
     int flag;
+    int ret;
     opal_cstring_t *info_str;
     *priority = 0;
 
@@ -104,8 +139,22 @@ struct mca_sharedfp_base_module_2_0_0_t * mca_sharedfp_individual_component_file
 
     /*---------------------------------------------------------*/
     /* 2. Did the user specify MPI_INFO relaxed ordering flag? */
+    if (wronly_flag) {
+        /*
+         * This hint is meaningful only when this component can be selected.
+         * Registering it conditionally avoids reporting a sharedfp hint as
+         * accepted on read-only opens where individual sharedfp will not run.
+         */
+        ret = mca_common_ompio_info_subscribe(fh, "OMPIO_SHAREDFP_RELAXED_ORDERING",
+                                              NULL,
+                                              mca_sharedfp_individual_relaxed_ordering_cb);
+        if (OMPI_SUCCESS != ret) {
+            return NULL;
+        }
+    }
+
     info = fh->f_info;
-    if ( info != &(MPI_INFO_NULL->super) ){
+    if ( wronly_flag && info != &(MPI_INFO_NULL->super) ){
         opal_info_get ( info,"OMPIO_SHAREDFP_RELAXED_ORDERING", &info_str, &flag);
         if ( flag ) {
            if ( mca_sharedfp_individual_verbose ) {
@@ -157,11 +206,18 @@ struct mca_sharedfp_base_module_2_0_0_t * mca_sharedfp_individual_component_file
 
 int mca_sharedfp_individual_component_file_unquery (ompio_file_t *file)
 {
-   /* This function might be needed for some purposes later. for now it
-    * does not have anything to do since there are no steps which need
-    * to be undone if this module is not selected */
+    /*
+     * The query path may have subscribed and accepted the relaxed-ordering
+     * hint so it could participate in priority selection.  If another
+     * sharedfp component wins, remove the public value; otherwise
+     * MPI_File_get_info would claim that a hint owned by the losing
+     * individual component is part of the active file stack.
+     */
+    if (NULL != file && NULL != file->f_info) {
+        (void) opal_info_delete(file->f_info, "OMPIO_SHAREDFP_RELAXED_ORDERING");
+    }
 
-   return OMPI_SUCCESS;
+    return OMPI_SUCCESS;
 }
 
 int mca_sharedfp_individual_module_init (ompio_file_t *file)
diff --git a/ompi/mca/sharedfp/individual/sharedfp_individual_file_open.c b/ompi/mca/sharedfp/individual/sharedfp_individual_file_open.c
index fbe0907167a..7dcd03170f3 100644
--- a/ompi/mca/sharedfp/individual/sharedfp_individual_file_open.c
+++ b/ompi/mca/sharedfp/individual/sharedfp_individual_file_open.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2015-2018 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -24,6 +25,8 @@
 #include "ompi_config.h"
 #include "sharedfp_individual.h"
 
+#include <stdlib.h>
+
 #include "mpi.h"
 #include "ompi/constants.h"
 #include "ompi/mca/sharedfp/sharedfp.h"
@@ -81,7 +84,7 @@ int mca_sharedfp_individual_file_open (struct ompi_communicator_t *comm,
     snprintf(datafilename, len, "%s%s%d",filename,".data.",fh->f_rank);
 
 
-    datafilehandle = (ompio_file_t *)malloc(sizeof(ompio_file_t));
+    datafilehandle = (ompio_file_t *) calloc(1, sizeof(ompio_file_t));
     if ( NULL == datafilehandle ) {
         opal_output(0, "mca_sharedfp_individual_file_open: unable to allocate memory\n");
         free ( sh );
@@ -130,7 +133,7 @@ int mca_sharedfp_individual_file_open (struct ompi_communicator_t *comm,
     }
     snprintf ( metadatafilename, len, "%s%s%d", filename, ".metadata.",fh->f_rank);
 
-    metadatafilehandle = (ompio_file_t *)malloc(sizeof(ompio_file_t));
+    metadatafilehandle = (ompio_file_t *) calloc(1, sizeof(ompio_file_t));
     if ( NULL == metadatafilehandle ) {
         free (sh);
         free (datafilename);
diff --git a/ompi/mca/sharedfp/sm/sharedfp_sm_file_open.c b/ompi/mca/sharedfp/sm/sharedfp_sm_file_open.c
index edc453a7add..0a1f0af9d78 100644
--- a/ompi/mca/sharedfp/sm/sharedfp_sm_file_open.c
+++ b/ompi/mca/sharedfp/sm/sharedfp_sm_file_open.c
@@ -15,6 +15,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2015-2021 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -182,12 +183,18 @@ int mca_sharedfp_sm_file_open (struct ompi_communicator_t *comm,
 
 #if defined(HAVE_SEM_OPEN)
 
+    /* POSIX requires a named-semaphore name to begin with '/' (and to
+       contain no other '/').  Linux and macOS tolerate a missing leading
+       slash, but FreeBSD enforces POSIX: sem_open() of a name that does not
+       start with '/' fails with EINVAL.  That made MPI_File_open() fail on
+       FreeBSD whenever the sm sharedfp component was selected (its default
+       priority is the highest), so always emit a leading-slash name. */
 #if defined (__APPLE__)
     sm_data->sem_name = (char*) malloc( sizeof(char) * 32);
-    snprintf(sm_data->sem_name,31,"OMPIO_%s",filename_basename);
+    snprintf(sm_data->sem_name,31,"/OMPIO_%s",filename_basename);
 #else
     sm_data->sem_name = (char*) malloc( sizeof(char) * 253);
-    snprintf(sm_data->sem_name,252,"OMPIO_%s",filename_basename);
+    snprintf(sm_data->sem_name,252,"/OMPIO_%s",filename_basename);
 #endif
     // We're now done with filename_basename.  Free it here so that we
     // don't have to keep freeing it in the error/return cases.
diff --git a/ompi/mca/topo/base/topo_base_dist_graph_create.c b/ompi/mca/topo/base/topo_base_dist_graph_create.c
index 66e2976deb5..43c899cb4b8 100644
--- a/ompi/mca/topo/base/topo_base_dist_graph_create.c
+++ b/ompi/mca/topo/base/topo_base_dist_graph_create.c
@@ -19,6 +19,7 @@
 #include "ompi_config.h"
 
 #include "ompi/communicator/communicator.h"
+#include "ompi/mca/coll/base/coll_tags.h"
 #include "ompi/info/info.h"
 #include "ompi/mca/topo/base/base.h"
 #include "ompi/datatype/ompi_datatype.h"
@@ -27,8 +28,6 @@
 
 #define IN_INDEX   0
 #define OUT_INDEX  1
-#define MCA_TOPO_BASE_TAG_DIST_EDGE_IN    -50
-#define MCA_TOPO_BASE_TAG_DIST_EDGE_OUT   -51
 
 typedef struct _dist_graph_elem {
     int in;
@@ -172,7 +171,7 @@ int mca_topo_base_dist_graph_distribute(mca_topo_base_module_t* module,
                 position *= 2;
             }
             err = MCA_PML_CALL(isend( &rin[position], count, (ompi_datatype_t*)&ompi_mpi_int,
-                                      i, MCA_TOPO_BASE_TAG_DIST_EDGE_IN, MCA_PML_BASE_SEND_STANDARD,
+                                      i, MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_IN, MCA_PML_BASE_SEND_STANDARD,
                                       comm, &reqs[pending_reqs]));
             pending_reqs++;
         }
@@ -183,7 +182,7 @@ int mca_topo_base_dist_graph_distribute(mca_topo_base_module_t* module,
                 position *= 2;
             }
             err = MCA_PML_CALL(isend(&rout[position], count, (ompi_datatype_t*)&ompi_mpi_int,
-                                     i, MCA_TOPO_BASE_TAG_DIST_EDGE_OUT, MCA_PML_BASE_SEND_STANDARD,
+                                     i, MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_OUT, MCA_PML_BASE_SEND_STANDARD,
                                      comm, &reqs[pending_reqs]));
             pending_reqs++;
         }
@@ -210,7 +209,7 @@ int mca_topo_base_dist_graph_distribute(mca_topo_base_module_t* module,
     for( left_over = count, current_pos = i = 0; left_over > 0; i++ ) {
 
         MCA_PML_CALL(recv( &temp[count - left_over], left_over, (ompi_datatype_t*)&ompi_mpi_int,  /* keep receiving in the same buffer */
-                           MPI_ANY_SOURCE, MCA_TOPO_BASE_TAG_DIST_EDGE_IN,
+                           MPI_ANY_SOURCE, MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_IN,
                            comm, &status ));
         how_much = status._ucount / int_size;
         if (MPI_UNWEIGHTED != weights) {
@@ -246,7 +245,7 @@ int mca_topo_base_dist_graph_distribute(mca_topo_base_module_t* module,
     for( left_over = count, current_pos = i = 0; left_over > 0; i++ ) {
 
         MCA_PML_CALL(recv( &temp[count - left_over], left_over, (ompi_datatype_t*)&ompi_mpi_int,  /* keep receiving in the same buffer */
-                           MPI_ANY_SOURCE, MCA_TOPO_BASE_TAG_DIST_EDGE_OUT,
+                           MPI_ANY_SOURCE, MCA_COLL_BASE_TAG_TOPO_DIST_EDGE_OUT,
                            comm, &status ));
         how_much = status._ucount / int_size;
 
diff --git a/ompi/mpi/Makefile.am b/ompi/mpi/Makefile.am
index 80ae278fde2..f740b22a9cf 100644
--- a/ompi/mpi/Makefile.am
+++ b/ompi/mpi/Makefile.am
@@ -12,7 +12,7 @@
 # Copyright (c) 2006-2018 Cisco Systems, Inc.  All rights reserved.
 # Copyright (c) 2015      Research Organization for Information Science
 #                         and Technology (RIST). All rights reserved.
-# Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2025-2026 Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -24,6 +24,7 @@ EXTRA_DIST += \
         mpi/fortran/configure-fortran-output-bottom.h \
         mpi/help-mpi-api.txt \
         mpi/bindings/bindings.py \
+        mpi/bindings/check_f08_names.py \
         mpi/bindings/ompi_bindings/consts.py \
         mpi/bindings/ompi_bindings/c.py \
         mpi/bindings/ompi_bindings/c_type.py \
diff --git a/ompi/mpi/bindings/bindings.py b/ompi/mpi/bindings/bindings.py
index 9fa858db93b..1dfd4c3377c 100644
--- a/ompi/mpi/bindings/bindings.py
+++ b/ompi/mpi/bindings/bindings.py
@@ -1,6 +1,7 @@
 # Copyright (c) 2024-2025 Triad National Security, LLC. All rights
 #                         reserved.
 #
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -35,6 +36,9 @@ def main():
                                 help='generate ts suffixes for appropriate routines')
     parser_fortran.add_argument('--fort-std', choices=('f90', 'f08'),
                              help='fortran standard to use for fortran module and code generation')
+    parser_fortran.add_argument('--pympistd-dir', default=None,
+                             help='path to the pympistandard submodule; when given, the generated '
+                                  'Fortran interfaces use the standard MPI dummy-argument names')
     # Handler for generating actual code
     subparsers_fortran = parser_fortran.add_subparsers()
     parser_code = subparsers_fortran.add_parser('code', help='generate binding code')
diff --git a/ompi/mpi/bindings/check_f08_names.py b/ompi/mpi/bindings/check_f08_names.py
new file mode 100644
index 00000000000..65cb18beecf
--- /dev/null
+++ b/ompi/mpi/bindings/check_f08_names.py
@@ -0,0 +1,311 @@
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+#
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+"""Validate the Open MPI mpi_f08 interfaces against the MPI standard.
+
+The mpi_f08 module is the only Fortran binding whose dummy-argument
+*names* are part of the user-visible contract (keyword arguments).  This
+script loads the MPI Forum's pympistandard metadata and checks that every
+mpi_f08 procedure's dummy arguments agree with the standard on three
+things:
+
+  * name      -- the dummy-argument name (case-insensitive)
+  * intent    -- INTENT(IN|OUT|INOUT)
+  * type      -- the declared Fortran type
+
+It is intended to be run at build time over the generated Fortran source
+(api_f08_generated.F90 and the interface headers) plus the hand-written
+*_f08.F90 files, and exits non-zero -- failing the build -- if any
+mpi_f08 interface has drifted from the standard.  Only the mpi_f08
+module is in scope; the C back-end and the older mpi (f90) module are
+not checked.
+
+Things the standard deliberately leaves to the implementation are not
+flagged:
+
+  * choice buffers (standard type 'TYPE(*), ...'); Open MPI renders
+    these with its own ignore-TKR macro and may attach INTENT(IN).
+  * any argument whose standard F08 intent is unspecified (None), e.g.
+    a TYPE(MPI_Status) argument that must also accept MPI_STATUS_IGNORE.
+  * a large-count (_c) procedure that the standard does not provide an
+    F08 binding for.
+"""
+
+import argparse
+import os
+import re
+import sys
+
+
+# Automake-style result colors (PASS=green, FAIL=red, SKIP=blue), matching
+# Automake's color-tests palette.
+_STATUS_COLOR = {'PASS': '\033[0;32m', 'FAIL': '\033[0;31m', 'SKIP': '\033[1;34m'}
+_COLOR_RESET = '\033[m'
+
+
+def _use_color():
+    """Colorize like Automake: AM_COLOR_TESTS=always forces it; otherwise a TTY."""
+    setting = os.environ.get('AM_COLOR_TESTS', '')
+    if setting == 'always':
+        return True
+    if setting == 'no' or os.environ.get('NO_COLOR'):
+        return False
+    return sys.stdout.isatty()
+
+
+def emit_status(status, label, reason=None):
+    """Print an Automake-style '<STATUS>: <label>' line, colorized if appropriate."""
+    tag = status
+    if _use_color():
+        tag = f'{_STATUS_COLOR[status]}{status}{_COLOR_RESET}'
+    line = f'{tag}: {label}'
+    if reason:
+        line += f' ({reason})'
+    print(line)
+
+
+def load_standard(pympistd_dir):
+    """Load {function_key: {'r': params, 'c': params}} from pympistandard.
+
+    Each params entry is a list of (name, intent, type) tuples for the
+    regular ('r') and large-count/embiggened ('c') F08 bindings.
+    """
+    sys.path.insert(0, os.path.join(pympistd_dir, 'src'))
+    import pympistandard as std
+    std.use_api_version(1)
+
+    def params_of(express):
+        f08 = getattr(express, 'f08', None) if express is not None else None
+        if f08 is None:
+            return None
+        return [(p.name.lower(), p.intent, p.type) for p in f08.parameters]
+
+    table = {}
+    for key, proc in std.PROCEDURES.items():
+        entry = {}
+        regular = params_of(proc.express)
+        if regular is not None:
+            entry['r'] = regular
+        embiggened = params_of(proc.express.embiggen)
+        if embiggened is not None:
+            entry['c'] = embiggened
+        if entry:
+            table[key.lower()] = entry
+    return table
+
+
+# Procedures whose Open MPI mpi_f08 binding intentionally has a different
+# argument count than the standard's F08 expression, so an argument-count
+# mismatch is expected rather than drift: MPI_Pcontrol is variadic, and the
+# Open MPI bindings for MPI_Type_get_contents / MPI_Type_get_envelope take a
+# different argument shape than pympistandard's rendering.
+COUNT_MISMATCH_EXEMPT = {
+    'mpi_pcontrol',
+    'mpi_type_get_contents',
+    'mpi_type_get_envelope',
+}
+
+
+def function_key(subroutine_name):
+    """Map an mpi_f08 subroutine name to a (pympistandard key, is_large_count) pair.
+
+    Large-count variants use two suffix conventions: the template-generated
+    routines use '_c_f08'/'_c_f08ts', while the hand-written ones use
+    '_f08_c'/'_f08ts_c'.  Both must be recognized so the large-count routines
+    resolve to the embiggened standard entry instead of being skipped.
+    """
+    is_c = bool(re.search(r'(_c_f08(ts)?|_f08(ts)?_c)$', subroutine_name))
+    base = re.sub(r'(_c_f08(ts)?|_f08(ts)?_c|_f08(ts)?)$', '', subroutine_name).lower()
+    if not base.startswith('mpi_'):
+        base = 'mpi_' + base
+    return base, is_c
+
+
+def normalize_type(text):
+    """Normalize a Fortran type for comparison."""
+    text = re.sub(r'\s+', '', text).upper().replace('KIND=', '')
+    # CHARACTER(LEN=*) and friends are all just CHARACTER for our purposes.
+    text = re.sub(r'CHARACTER\(.*\)', 'CHARACTER', text)
+    return text
+
+
+def is_choice_buffer(std_type):
+    """A standard choice-buffer argument renders as 'TYPE(*), ...'."""
+    return 'TYPE(*)' in std_type
+
+
+def parse_fortran(path):
+    """Yield (subroutine_name, [arg_names], {arg: (intent, base_type)}) per top-level routine."""
+    lines = open(path).read().split('\n')
+    i, n = 0, len(lines)
+    while i < n:
+        s = lines[i].strip()
+        m = re.match(r'(?:pure\s+|elemental\s+)?subroutine\s+(MPI_\w+)\s*\(', s)
+        if not m:
+            i += 1
+            continue
+        name = m.group(1)
+        # Gather a possibly continued signature.
+        sig, j = s, i
+        while sig.rstrip().endswith('&'):
+            j += 1
+            sig = sig.rstrip()[:-1] + lines[j].strip()
+        arglist = re.search(r'\((.*)\)', sig).group(1)
+        args = [a.strip().lower() for a in arglist.split(',')
+                if a.strip() and a.strip().lower() != 'ierror']
+        # Collect dummy declarations up to the first nested interface / end.
+        decls = {}
+        k = j + 1
+        while k < n:
+            low = lines[k].strip().lower()
+            if re.match(r'^interface\b', low) or re.match(r'^end\s+subroutine', low):
+                break
+            if '::' in lines[k]:
+                upper = lines[k].upper()
+                has_intent = 'INTENT(' in upper
+                is_buffer = 'TYPE(*)' in upper or 'IGNORE_TKR' in upper
+                if has_intent or is_buffer:
+                    intent = ('INTENT(INOUT)' if 'INTENT(INOUT)' in upper else
+                              'INTENT(OUT)' if 'INTENT(OUT)' in upper else
+                              'INTENT(IN)' if 'INTENT(IN)' in upper else None)
+                    # Base type: text before the first top-level comma of the LHS.
+                    lhs = lines[k].split('::', 1)[0]
+                    base, depth = '', 0
+                    for ch in lhs:
+                        if ch == '(':
+                            depth += 1
+                        elif ch == ')':
+                            depth -= 1
+                        elif ch == ',' and depth == 0:
+                            break
+                        base += ch
+                    # Declared names (before any '(' dimension spec, top-level commas).
+                    rhs = lines[k].split('::', 1)[1].split('!')[0]
+                    buf, depth, names = '', 0, []
+                    for ch in rhs:
+                        if ch == '(':
+                            depth += 1
+                            if depth == 1:
+                                names.append(buf)
+                                buf = ''
+                        elif ch == ')':
+                            depth -= 1
+                        elif ch == ',' and depth == 0:
+                            names.append(buf)
+                            buf = ''
+                        elif depth == 0:
+                            buf += ch
+                    names.append(buf)
+                    for nm in names:
+                        nm = nm.strip().lower()
+                        if re.match(r'^[a-z]\w*$', nm):
+                            decls[nm] = (intent, base.strip())
+            k += 1
+        yield name, args, decls
+        i = j + 1
+
+
+def check_file(path, table, matched):
+    """Return mismatch strings for one file; add fully-checked routines to `matched`."""
+    problems = []
+    for name, args, decls in parse_fortran(path):
+        key, is_c = function_key(name)
+        entry = table.get(key)
+        if entry is None:
+            # No standard metadata for this routine (an Open MPI extension, or
+            # a routine newer than the pympistandard in use) -- nothing to
+            # check it against.
+            continue
+        expected = entry.get('c') if is_c else entry.get('r')
+        if expected is None:
+            # OMPI provides a large-count variant the standard does not.
+            continue
+        expected = [(n, i, t) for (n, i, t) in expected if n != 'ierror']
+        if len(args) != len(expected):
+            # An unexpected argument-count difference is real drift; a few
+            # routines legitimately differ (see COUNT_MISMATCH_EXEMPT).
+            if key not in COUNT_MISMATCH_EXEMPT:
+                problems.append(f'{name}: has {len(args)} non-ierror argument(s) but the '
+                                f'standard specifies {len(expected)} (argument added or removed?)')
+            continue
+        matched.add(name)
+        for got_name, (std_name, std_intent, std_type) in zip(args, expected):
+            if got_name != std_name:
+                problems.append(f'{name}: argument {got_name!r} should be named '
+                                f'{std_name!r}')
+            got_intent, got_type = decls.get(got_name, (None, None))
+            # Intent: skip where the standard leaves it unspecified.
+            if std_intent is not None and got_intent is not None and got_intent != std_intent:
+                problems.append(f'{name}: argument {std_name!r} has {got_intent}, '
+                                f'standard requires {std_intent}')
+            # Type: skip choice buffers (implementation-defined rendering).
+            if (got_type is not None and not is_choice_buffer(std_type)
+                    and 'IGNORE_TKR' not in got_type.upper()):
+                if normalize_type(got_type) != normalize_type(std_type):
+                    problems.append(f'{name}: argument {std_name!r} is declared '
+                                    f'{got_type!r}, standard requires {std_type!r}')
+    return problems
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Validate mpi_f08 interfaces against the MPI standard (pympistandard).')
+    parser.add_argument('--pympistd-dir', required=True,
+                        help='path to the pympistandard submodule')
+    parser.add_argument('--label', default='mpi_f08 interfaces',
+                        help='label for the Automake-style PASS/FAIL/SKIP result line')
+    parser.add_argument('files', nargs='+',
+                        help='Fortran files containing mpi_f08 interfaces to check')
+    args = parser.parse_args()
+    label = args.label
+
+    # Skip (don't fail) when the mpi_f08 sources are not present -- e.g. the
+    # Fortran bindings were not built.  (The Makefiles only run this during
+    # "make check" when the f08 bindings are enabled, but stay robust anyway.)
+    if not any(os.path.exists(f) for f in args.files):
+        emit_status('SKIP', label, 'mpi_f08 sources not built')
+        return
+
+    # Skip when pympistandard is unavailable (e.g. the submodule was not
+    # checked out).  The generator falls back the same way; a build with
+    # pympistandard present is what enforces standard names.
+    if not os.path.isdir(os.path.join(args.pympistd_dir, 'src')):
+        emit_status('SKIP', label, 'pympistandard not available')
+        return
+    try:
+        table = load_standard(args.pympistd_dir)
+    except ImportError as e:
+        emit_status('SKIP', label, f'pympistandard could not be loaded: {e}')
+        return
+
+    problems = []
+    matched = set()
+    for path in args.files:
+        if os.path.exists(path):
+            problems.extend(check_file(path, table, matched))
+
+    # Guard against silently validating nothing: if files were present but not
+    # a single routine matched a standard entry, the pympistandard key format
+    # has almost certainly drifted from what this script expects, so a "pass"
+    # would be meaningless.  Fail loudly instead.
+    if not matched:
+        emit_status('FAIL', label, 'matched 0 procedures; pympistandard key format may have changed')
+        sys.exit(1)
+
+    if problems:
+        print('mpi_f08 interfaces disagree with the MPI standard:')
+        for p in problems:
+            print(f'  {p}')
+        print(f'{len(problems)} mismatch(es) found ({len(matched)} procedures validated).')
+        emit_status('FAIL', label)
+        sys.exit(1)
+
+    emit_status('PASS', label, f'{len(matched)} procedures validated')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/ompi/mpi/bindings/ompi_bindings/c.py b/ompi/mpi/bindings/ompi_bindings/c.py
index 162c8a762e6..7d99d7f2620 100644
--- a/ompi/mpi/bindings/ompi_bindings/c.py
+++ b/ompi/mpi/bindings/ompi_bindings/c.py
@@ -286,7 +286,7 @@ def dump_header(self):
 def print_profiling_header(fn_name, out):
     """Print the profiling header code."""
     out.dump('#if OMPI_BUILD_MPI_PROFILING')
-    out.dump('#if OPAL_HAVE_WEAK_SYMBOLS')
+    out.dump('#if OPAL_HAVE_WEAK_ALIASES')
     out.dump(f'#pragma weak {fn_name} = P{fn_name}')
     out.dump('#endif')
     out.dump(f'#define {fn_name} P{fn_name}')
diff --git a/ompi/mpi/bindings/ompi_bindings/consts.py b/ompi/mpi/bindings/ompi_bindings/consts.py
index 43bca486b57..4a249629079 100644
--- a/ompi/mpi/bindings/ompi_bindings/consts.py
+++ b/ompi/mpi/bindings/ompi_bindings/consts.py
@@ -75,6 +75,8 @@
     'MPI_ERR_RMA_FLAVOR',
     'MPI_ERR_SERVICE',
     'MPI_ERR_SESSION',
+    'MPI_ERR_VALUE_TOO_LARGE',
+    'MPI_ERR_ERRHANDLER',
     'MPI_ERR_SIZE',
     'MPI_ERR_SPAWN',
     'MPI_ERR_UNSUPPORTED_DATAREP',
@@ -96,6 +98,9 @@
     'MPI_T_ERR_PVAR_NO_WRITE',
     'MPI_T_ERR_PVAR_NO_STARTSTOP',
     'MPI_T_ERR_PVAR_NO_ATOMIC',
+    'MPI_T_ERR_NOT_ACCESSIBLE',
+    'MPI_T_ERR_NOT_SUPPORTED',
+    'MPI_ERR_RMA_NOTIFICATION',
     'MPI_ERR_LASTCODE',
 ]
 
diff --git a/ompi/mpi/bindings/ompi_bindings/fortran.py b/ompi/mpi/bindings/ompi_bindings/fortran.py
index 5e4256eacab..ada78106c5a 100644
--- a/ompi/mpi/bindings/ompi_bindings/fortran.py
+++ b/ompi/mpi/bindings/ompi_bindings/fortran.py
@@ -1,6 +1,7 @@
-# Copyright (c) 2024-2025 Triad National Security, LLC. All rights
+# Copyright (c) 2024-2026 Triad National Security, LLC. All rights
 #                         reserved.
 #
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -16,16 +17,57 @@
 """
 from collections import namedtuple
 import json
+import os
 import re
+import sys
 from ompi_bindings import consts, util
 from ompi_bindings.fortran_type import FortranType
 from ompi_bindings.parser import SourceTemplate
 
 
+# Cache of {function_name_lower: [standard f08 dummy-argument names]} loaded
+# from pympistandard.  None means "not yet attempted"; an empty dict means
+# "attempted but unavailable" (the generator then falls back to the names
+# hard-coded in the *.in PROTOTYPE lines).
+_STANDARD_F08_NAMES = None
+
+
+def standard_f08_names(pympistd_dir):
+    """Load the standard MPI F08 dummy-argument names from pympistandard.
+
+    The Open MPI templates use generic internal names (e.g. 'x', 'x1') for
+    the choice-buffer arguments; the C back-end code refers to those names.
+    The user-visible mpi_f08 interfaces, however, must use the parameter
+    names mandated by the MPI standard so that keyword arguments work.  This
+    returns, per function, the ordered list of standard F08 dummy names
+    (excluding ierror), which the Fortran generator substitutes for the
+    template names -- without touching the C back-end.
+    """
+    global _STANDARD_F08_NAMES
+    if _STANDARD_F08_NAMES is not None:
+        return _STANDARD_F08_NAMES
+    names = {}
+    if pympistd_dir:
+        src = os.path.join(pympistd_dir, 'src')
+        if os.path.isdir(src):
+            sys.path.insert(0, src)
+            import pympistandard as std
+            std.use_api_version(1)
+            for key, proc in std.PROCEDURES.items():
+                f08 = getattr(proc.express, 'f08', None)
+                if f08 is None:
+                    continue
+                names[key.lower()] = [p.name.lower() for p in f08.parameters
+                                      if p.name.lower() != consts.FORTRAN_ERROR_NAME]
+    _STANDARD_F08_NAMES = names
+    return names
+
+
 class FortranBinding:
     """Class for generating the binding for a single function."""
 
-    def __init__(self, prototype, out, template=None, bigcount=False, needs_ts=False, gen_f90=False):
+    def __init__(self, prototype, out, template=None, bigcount=False, needs_ts=False,
+                 gen_f90=False, f08_names=None):
         # Generate bigcount interface version
         self.bigcount = bigcount
         self.fn_name = template.prototype.name
@@ -38,6 +80,16 @@ def __init__(self, prototype, out, template=None, bigcount=False, needs_ts=False
             self.parameters.append(param.construct(fn_name=self.fn_name,
                                                    bigcount=bigcount,
                                                    gen_f90=gen_f90))
+        # For Fortran generation, replace the template's internal parameter
+        # names with the standard MPI F08 dummy-argument names.  Only done
+        # when the count of standard names matches (i.e. the prototype and the
+        # standard agree on the number of non-ierror arguments); otherwise the
+        # template names are kept so a misaligned prototype never silently
+        # emits a wrong name.  The C back-end (print_c_source) constructs its
+        # own FortranBinding without f08_names, so it is unaffected.
+        if f08_names is not None and len(f08_names) == len(self.parameters):
+            for param, std_name in zip(self.parameters, f08_names):
+                param.name = std_name
 
     def dump(self, *pargs, **kwargs):
         """Write to the output file."""
@@ -261,6 +313,7 @@ def print_c_source_header(out):
     out.dump('#include "ompi/mpi/fortran/mpif-h/status-conversion.h"')
     out.dump('#include "ompi/mpi/fortran/base/constants.h"')
     out.dump('#include "ompi/mpi/fortran/base/fint_2_int.h"')
+    out.dump('#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"')
     out.dump('#include "ompi/request/request.h"')
     out.dump('#include "ompi/communicator/communicator.h"')
     out.dump('#include "ompi/win/win.h"')
@@ -273,9 +326,10 @@ def print_c_source_header(out):
     out.dump('#include "bigcount.h"')
 
 
-def print_binding(prototype, lang, out, bigcount=False, template=None, needs_ts=False, gen_f90=False):
+def print_binding(prototype, lang, out, bigcount=False, template=None, needs_ts=False, gen_f90=False, f08_names=None):
     """Print the binding with or without bigcount."""
-    binding = FortranBinding(prototype, out=out, bigcount=bigcount, template=template, needs_ts=needs_ts, gen_f90=gen_f90)
+    binding = FortranBinding(prototype, out=out, bigcount=bigcount, template=template, needs_ts=needs_ts,
+                             gen_f90=gen_f90, f08_names=f08_names)
     if lang == 'fortran':
         binding.print_f_source()
     else:
@@ -299,6 +353,11 @@ def generate_code(args, out):
     else:
         gen_f90 = True
 
+    # Standard F08 dummy-argument names are only applied to the F08 Fortran
+    # interfaces, never to the C back-end (whose body refers to the template's
+    # internal names) and not to the older mpi (f90) module.
+    std_names = standard_f08_names(args.pympistd_dir) if (args.lang == 'fortran' and not gen_f90) else {}
+
     if args.lang == 'fortran':
         print_f_source_header(out)
         out.dump()
@@ -311,10 +370,13 @@ def generate_code(args, out):
         out.dump()
         has_buffers = util.prototype_has_buffers(template.prototype)
         needs_ts = has_buffers and args.generate_ts_suffix
-        print_binding(template.prototype, args.lang, out, template=template, needs_ts=needs_ts, gen_f90=gen_f90)
+        f08_names = std_names.get('mpi_' + template.prototype.name.lower())
+        print_binding(template.prototype, args.lang, out, template=template, needs_ts=needs_ts,
+                      gen_f90=gen_f90, f08_names=f08_names)
         if util.prototype_has_bigcount(template.prototype) and gen_f90 == False:
             out.dump()
-            print_binding(template.prototype, args.lang, bigcount=True, out=out, template=template, needs_ts=needs_ts)
+            print_binding(template.prototype, args.lang, bigcount=True, out=out, template=template,
+                          needs_ts=needs_ts, f08_names=f08_names)
 
 
 def generate_interface(args, out):
@@ -329,16 +391,23 @@ def generate_interface(args, out):
     else:
         gen_f90 = True
 
+    # The interface specifications are part of the user-visible mpi_f08
+    # module, so they use the standard MPI dummy-argument names too.  The
+    # older mpi (f90) module is out of scope.
+    std_names = standard_f08_names(args.pympistd_dir) if not gen_f90 else {}
+
     for template in templates:
         ext_name = util.ext_api_func_name(template.prototype.name)
         out.dump(f'interface {ext_name}')
         has_buffers = util.prototype_has_buffers(template.prototype)
         needs_ts = has_buffers and args.generate_ts_suffix
-        binding = FortranBinding(template.prototype, template=template, needs_ts=needs_ts, gen_f90=gen_f90, out=out)
+        f08_names = std_names.get('mpi_' + template.prototype.name.lower())
+        binding = FortranBinding(template.prototype, template=template, needs_ts=needs_ts,
+                                 gen_f90=gen_f90, out=out, f08_names=f08_names)
         binding.print_interface()
         if util.prototype_has_bigcount(template.prototype) and gen_f90 == False:
             out.dump()
             binding_c = FortranBinding(template.prototype, out=out, template=template,
-                                       needs_ts=needs_ts, bigcount=True)
+                                       needs_ts=needs_ts, bigcount=True, f08_names=f08_names)
             binding_c.print_interface()
         out.dump(f'end interface {ext_name}')
diff --git a/ompi/mpi/c/Makefile.am b/ompi/mpi/c/Makefile.am
index 25b871fa7d4..e4b6367045f 100644
--- a/ompi/mpi/c/Makefile.am
+++ b/ompi/mpi/c/Makefile.am
@@ -35,7 +35,7 @@
 # every MPI function twice.  We always build the profiling layer,
 # because the symbols that are always implemented as functions are the
 # PMPI_ namespace symbols.  We sometimes also build the non-profiling
-# layer, if weak symbols can't be used to alias the MPI_ namespace
+# layer, if weak aliases can't be used to alias the MPI_ namespace
 # into the PMPI_ namespace.
 
 include $(top_srcdir)/Makefile.ompi-rules
@@ -56,6 +56,7 @@ headers = bindings.h
 prototype_sources = \
         abort.c.in \
         accumulate.c.in \
+        accumulate_notify.c.in \
         add_error_class.c.in \
         add_error_code.c.in \
         add_error_string.c.in \
@@ -221,8 +222,10 @@ prototype_sources = \
 	gatherv.c.in \
 	gatherv_init.c.in \
 	get_accumulate.c.in \
+	get_accumulate_notify.c.in \
 	get_address.c.in \
 	get.c.in \
+	get_notify.c.in \
 	get_count.c.in \
 	get_elements.c.in \
 	get_elements_x.c.in \
@@ -341,8 +344,10 @@ prototype_sources = \
 	psend_init.c.in \
 	publish_name.c.in \
 	put.c.in \
+	put_notify.c.in \
 	query_thread.c.in \
 	raccumulate.c.in \
+	raccumulate_notify.c.in \
         recv.c.in \
 	recv_init.c.in \
 	reduce.c.in \
@@ -364,8 +369,11 @@ prototype_sources = \
 	request_get_status_any.c.in \
 	request_get_status_some.c.in \
 	rget_accumulate.c.in \
+	rget_accumulate_notify.c.in \
 	rget.c.in \
+	rget_notify.c.in \
 	rput.c.in \
+	rput_notify.c.in \
 	rsend.c.in \
 	rsend_init.c.in \
         scan.c.in \
@@ -484,6 +492,10 @@ prototype_sources = \
 	win_get_group.c.in \
 	win_get_info.c.in \
 	win_get_name.c.in \
+	win_get_notify_value.c.in \
+	win_reset_notify_value.c.in \
+	win_get_num_notify.c.in \
+	win_set_num_notify.c.in \
 	win_lock_all.c.in \
 	win_lock.c.in \
 	win_post.c.in \
@@ -526,6 +538,7 @@ endif
 interface_profile_sources = \
 	abort_generated.c \
 	accumulate_generated.c \
+	accumulate_notify_generated.c \
 	add_error_class_generated.c \
 	add_error_code_generated.c \
 	add_error_string_generated.c \
@@ -691,6 +704,7 @@ interface_profile_sources = \
 	gatherv_generated.c \
 	gatherv_init_generated.c \
 	get_accumulate_generated.c \
+	get_accumulate_notify_generated.c \
 	get_address_generated.c \
 	get_generated.c \
 	get_count_generated.c \
@@ -698,6 +712,7 @@ interface_profile_sources = \
 	get_elements_x_generated.c \
 	get_hw_resource_info_generated.c \
 	get_library_version_generated.c \
+	get_notify_generated.c \
 	get_processor_name_generated.c \
 	get_version_generated.c \
 	graph_create_generated.c \
@@ -811,8 +826,10 @@ interface_profile_sources = \
 	psend_init_generated.c \
 	publish_name_generated.c \
 	put_generated.c \
+	put_notify_generated.c \
 	query_thread_generated.c \
 	raccumulate_generated.c \
+	raccumulate_notify_generated.c \
 	recv_generated.c \
 	recv_init_generated.c \
 	reduce_generated.c \
@@ -834,8 +851,11 @@ interface_profile_sources = \
 	request_get_status_any_generated.c \
 	request_get_status_some_generated.c \
 	rget_accumulate_generated.c \
+	rget_accumulate_notify_generated.c \
 	rget_generated.c \
+	rget_notify_generated.c \
 	rput_generated.c \
+	rput_notify_generated.c \
 	rsend_generated.c \
 	rsend_init_generated.c \
 	scan_generated.c \
@@ -954,6 +974,10 @@ interface_profile_sources = \
 	win_get_group_generated.c \
 	win_get_info_generated.c \
 	win_get_name_generated.c \
+	win_get_notify_value_generated.c \
+	win_reset_notify_value_generated.c \
+	win_get_num_notify_generated.c \
+	win_set_num_notify_generated.c \
 	win_lock_all_generated.c \
 	win_lock_generated.c \
 	win_post_generated.c \
diff --git a/ompi/mpi/c/accumulate_notify.c.in b/ompi/mpi/c/accumulate_notify.c.in
new file mode 100644
index 00000000000..395dd3cad24
--- /dev/null
+++ b/ompi/mpi/c/accumulate_notify.c.in
@@ -0,0 +1,141 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2009      Sun Microsystmes, Inc.  All rights reserved.
+ * Copyright (c) 2013-2015 Los Alamos National Security, LLC. All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+#include <stdio.h>
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/op/op.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/datatype/ompi_datatype_internal.h"
+#include "ompi/memchecker.h"
+
+PROTOTYPE ERROR_CLASS accumulate_notify(BUFFER origin_addr, COUNT origin_count, DATATYPE origin_datatype,
+                                        INT target_rank, AINT target_disp, COUNT target_count,
+                                        DATATYPE target_datatype, OP op, INT notification_idx,
+                                        WIN win)
+{
+    int rc;
+    ompi_win_t *ompi_win = (ompi_win_t*) win;
+
+    MEMCHECKER(
+        memchecker_datatype(origin_datatype);
+        memchecker_datatype(target_datatype);
+        memchecker_call(&opal_memchecker_base_isdefined, (void *) origin_addr, origin_count, origin_datatype);
+    );
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if (MPI_OP_NULL == op || MPI_NO_OP == op) {
+            rc = MPI_ERR_OP;
+        } else if (!ompi_op_is_intrinsic(op)) {
+            rc = MPI_ERR_OP;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            /* The upper bound depends on how many counters the *target* has
+               attached, which only the osc module can see, so the range check
+               proper happens there. */
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+            if (OMPI_SUCCESS == rc) {
+                /* While technically the standard probably requires that the
+                   datatypes used with MPI_REPLACE conform to all the rules
+                   for other reduction operators, we don't require such
+                   behavior, as checking for it is expensive here and we don't
+                   care in implementation.. */
+                if (op != &ompi_mpi_op_replace.op && op != &ompi_mpi_op_no_op.op) {
+                    ompi_datatype_t *op_check_dt, *origin_check_dt;
+                    char *msg;
+
+                    /* ACCUMULATE, unlike REDUCE, can use with derived
+                       datatypes with predefinied operations, with some
+                       restrictions outlined in MPI-3:11.3.4.  The derived
+                       datatype must be composed entirely from one predefined
+                       datatype (so you can do all the construction you want,
+                       but at the bottom, you can only use one datatype, say,
+                       MPI_INT).  If the datatype at the target isn't
+                       predefined, then make sure it's composed of only one
+                       datatype, and check that datatype against
+                       ompi_op_is_valid(). */
+                    origin_check_dt = ompi_datatype_get_single_predefined_type_from_args(origin_datatype);
+                    op_check_dt = ompi_datatype_get_single_predefined_type_from_args(target_datatype);
+
+                    if( !((origin_check_dt == op_check_dt) & (NULL != op_check_dt)) ) {
+                        OMPI_ERRHANDLER_RETURN(MPI_ERR_ARG, win, MPI_ERR_ARG, FUNC_NAME);
+                    }
+
+                    /* check to make sure primitive type is valid for
+                       reduction.  Should do this on the target, but
+                       then can't get the errcode back for this
+                       call */
+                    if (!ompi_op_is_valid(op, op_check_dt, &msg, FUNC_NAME)) {
+                        int ret = OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_OP, msg);
+                        free(msg);
+                        return ret;
+                    }
+                }
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_accumulate_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) {
+        return MPI_SUCCESS;
+    }
+
+    rc = ompi_win->w_osc_module->osc_accumulate_notify(origin_addr,
+                                                       origin_count,
+                                                       origin_datatype,
+                                                       target_rank,
+                                                       target_disp,
+                                                       target_count,
+                                                       target_datatype,
+                                                       op, notification_idx, win);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/address.c b/ompi/mpi/c/address.c
index f17d355972a..3db338a55ef 100644
--- a/ompi/mpi/c/address.c
+++ b/ompi/mpi/c/address.c
@@ -34,7 +34,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Address = PMPI_Address
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/comm_buffer_attach.c.in b/ompi/mpi/c/comm_buffer_attach.c.in
deleted file mode 100644
index 879e42e0ddf..00000000000
--- a/ompi/mpi/c/comm_buffer_attach.c.in
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2020 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-#include "ompi_config.h"
-#include <stdio.h>
-
-#include "ompi/mpi/c/bindings.h"
-#include "ompi/runtime/params.h"
-#include "ompi/communicator/communicator.h"
-#include "ompi/errhandler/errhandler.h"
-#include "ompi/mca/pml/pml.h"
-#include "ompi/mca/pml/base/pml_base_bsend.h"
-
-PROTOTYPE ERROR_CLASS comm_attach_buffer(COMM comm, BUFFER buffer, COUNT size)
-{
-    int ret = OMPI_SUCCESS;
-
-    if (MPI_PARAM_CHECK) {
-        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-
-        if ( ompi_comm_invalid (comm)) {
-            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(
-                                          MPI_ERR_COMM, FUNC_NAME);
-        }
-
-        if (NULL == buffer || size < 0) {
-           return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG, FUNC_NAME);
-        }
-    }
-
-    ret = mca_pml_base_bsend_attach(buffer, size);
-
-    return ret;
-}
-
diff --git a/ompi/mpi/c/comm_split_type.c.in b/ompi/mpi/c/comm_split_type.c.in
index 0bac2380019..faaa7896e02 100644
--- a/ompi/mpi/c/comm_split_type.c.in
+++ b/ompi/mpi/c/comm_split_type.c.in
@@ -17,6 +17,7 @@
  * Copyright (c) 2017-2022 IBM Corporation.  All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -61,6 +62,7 @@ PROTOTYPE ERROR_CLASS comm_split_type(COMM comm, INT split_type, INT key,
              MPI_COMM_TYPE_HW_GUIDED != split_type &&
              MPI_COMM_TYPE_RESOURCE_GUIDED != split_type &&
 	     OMPI_COMM_TYPE_CLUSTER != split_type &&
+	     OMPI_COMM_TYPE_NVLINK != split_type &&
 	     OMPI_COMM_TYPE_CU != split_type &&
 	     OMPI_COMM_TYPE_HOST != split_type &&
 	     OMPI_COMM_TYPE_BOARD != split_type &&
diff --git a/ompi/mpi/c/errhandler_create.c b/ompi/mpi/c/errhandler_create.c
index 44ad84b6e18..9b8b4da5a39 100644
--- a/ompi/mpi/c/errhandler_create.c
+++ b/ompi/mpi/c/errhandler_create.c
@@ -32,7 +32,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Errhandler_create = PMPI_Errhandler_create
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/errhandler_get.c b/ompi/mpi/c/errhandler_get.c
index b1a9dbc2cb4..736bc4ac957 100644
--- a/ompi/mpi/c/errhandler_get.c
+++ b/ompi/mpi/c/errhandler_get.c
@@ -34,7 +34,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Errhandler_get = PMPI_Errhandler_get
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/errhandler_set.c b/ompi/mpi/c/errhandler_set.c
index 604205ca99e..0b74a929da8 100644
--- a/ompi/mpi/c/errhandler_set.c
+++ b/ompi/mpi/c/errhandler_set.c
@@ -34,7 +34,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Errhandler_set = PMPI_Errhandler_set
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/exscan.c.in b/ompi/mpi/c/exscan.c.in
index 0268810658c..0bf6e03d67f 100644
--- a/ompi/mpi/c/exscan.c.in
+++ b/ompi/mpi/c/exscan.c.in
@@ -62,8 +62,15 @@ PROTOTYPE ERROR_CLASS exscan(BUFFER sendbuf, BUFFER_OUT recvbuf, COUNT count,
                                           FUNC_NAME);
         }
 
-        /* Unrooted operation -- same checks for intracommunicators
-           and intercommunicators */
+        /* No intercommunicators allowed! (MPI does not define
+           MPI_EXSCAN on intercommunicators) */
+
+        else if (OMPI_COMM_IS_INTER(comm)) {
+          err = MPI_ERR_COMM;
+        }
+
+        /* Unrooted operation; checks for all ranks */
+
         else if (MPI_OP_NULL == op) {
             err = MPI_ERR_OP;
         } else if (!ompi_op_is_valid(op, datatype, &msg, FUNC_NAME)) {
diff --git a/ompi/mpi/c/get_accumulate_notify.c.in b/ompi/mpi/c/get_accumulate_notify.c.in
new file mode 100644
index 00000000000..2c16e79299c
--- /dev/null
+++ b/ompi/mpi/c/get_accumulate_notify.c.in
@@ -0,0 +1,150 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2009      Sun Microsystmes, Inc.  All rights reserved.
+ * Copyright (c) 2013-2015 Los Alamos National Security, LLC. All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+#include <stdio.h>
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/op/op.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/datatype/ompi_datatype_internal.h"
+#include "ompi/memchecker.h"
+
+PROTOTYPE ERROR_CLASS get_accumulate_notify(BUFFER origin_addr, COUNT origin_count, DATATYPE origin_datatype,
+                                            BUFFER_OUT result_addr, COUNT result_count, DATATYPE result_datatype,
+                                            INT target_rank, AINT target_disp, COUNT target_count,
+                                            DATATYPE target_datatype, OP op, INT notification_idx,
+                                            WIN win)
+{
+    int rc;
+    ompi_win_t *ompi_win = (ompi_win_t*) win;
+
+    MEMCHECKER(
+        memchecker_datatype(origin_datatype);
+        memchecker_datatype(target_datatype);
+        memchecker_call(&opal_memchecker_base_isdefined, (void *) origin_addr, origin_count, origin_datatype);
+    );
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if (MPI_OP_NULL == op) {
+            rc = MPI_ERR_OP;
+        } else if (!ompi_op_is_intrinsic(op)) {
+            rc = MPI_ERR_OP;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            /* The upper bound depends on how many counters the *target* has
+               attached, which only the osc module can see, so the range check
+               proper happens there. */
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            /* the origin datatype is meaningless when using MPI_OP_NO_OP */
+            if (&ompi_mpi_op_no_op.op != op) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            } else {
+                rc = OMPI_SUCCESS;
+            }
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+            if (OMPI_SUCCESS == rc) {
+                /* While technically the standard probably requires that the
+                   datatypes used with MPI_REPLACE conform to all the rules
+                   for other reduction operators, we don't require such
+                   behavior, as checking for it is expensive here and we don't
+                   care in implementation.. */
+                if (op != &ompi_mpi_op_replace.op && op != &ompi_mpi_op_no_op.op) {
+                    ompi_datatype_t *op_check_dt, *origin_check_dt;
+                    char *msg;
+
+                    /* GET_ACCUMULATE, unlike REDUCE, can use with derived
+                       datatypes with predefinied operations, with some
+                       restrictions outlined in MPI-3:11.3.4.  The derived
+                       datatype must be composed entirely from one predefined
+                       datatype (so you can do all the construction you want,
+                       but at the bottom, you can only use one datatype, say,
+                       MPI_INT).  If the datatype at the target isn't
+                       predefined, then make sure it's composed of only one
+                       datatype, and check that datatype against
+                       ompi_op_is_valid(). */
+                    origin_check_dt = ompi_datatype_get_single_predefined_type_from_args(origin_datatype);
+                    op_check_dt = ompi_datatype_get_single_predefined_type_from_args(target_datatype);
+
+                    if( !((origin_check_dt == op_check_dt) & (NULL != op_check_dt)) ) {
+                        OMPI_ERRHANDLER_RETURN(MPI_ERR_ARG, win, MPI_ERR_ARG, FUNC_NAME);
+                    }
+
+                    /* check to make sure primitive type is valid for
+                       reduction.  Should do this on the target, but
+                       then can't get the errcode back for this
+                       call */
+                    if (!ompi_op_is_valid(op, op_check_dt, &msg, FUNC_NAME)) {
+                        int ret = OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_OP, msg);
+                        free(msg);
+                        return ret;
+                    }
+                }
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_get_accumulate_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) {
+        return MPI_SUCCESS;
+    }
+
+    rc = ompi_win->w_osc_module->osc_get_accumulate_notify(origin_addr,
+                                                           origin_count,
+                                                           origin_datatype,
+                                                           result_addr,
+                                                           result_count,
+                                                           result_datatype,
+                                                           target_rank,
+                                                           target_disp,
+                                                           target_count,
+                                                           target_datatype,
+                                                           op, notification_idx, win);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/get_count.c.in b/ompi/mpi/c/get_count.c.in
index c2daea1543e..bcc328f8ed5 100644
--- a/ompi/mpi/c/get_count.c.in
+++ b/ompi/mpi/c/get_count.c.in
@@ -63,11 +63,21 @@ PROTOTYPE ERROR_CLASS get_count(STATUS status, DATATYPE datatype, COUNT_OUT coun
             *count = 0;
         } else {
             internal_count = status->_ucount / size; /* count the number of complete datatypes */
-            if( (internal_count * size) != status->_ucount ||
-                internal_count > ((size_t) INT_MAX) ) {
+            if( (internal_count * size) != status->_ucount ) {
+                /* received bytes are not a whole number of datatype copies */
+                *count = MPI_UNDEFINED;
+#if OMPI_BIGCOUNT_SRC
+            } else if( internal_count > ((size_t) MPI_COUNT_MAX) ) {
+                /* bound against the OUT parameter's own limit, not INT_MAX */
+                *count = MPI_UNDEFINED;
+            } else {
+                *count = (MPI_Count) internal_count;
+#else
+            } else if( internal_count > ((size_t) INT_MAX) ) {
                 *count = MPI_UNDEFINED;
             } else {
                 *count = (int)internal_count;
+#endif
             }
         }
     }
diff --git a/ompi/mpi/c/get_elements.c.in b/ompi/mpi/c/get_elements.c.in
index 49483f92f5d..9c9d1513c87 100644
--- a/ompi/mpi/c/get_elements.c.in
+++ b/ompi/mpi/c/get_elements.c.in
@@ -16,6 +16,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -66,7 +67,8 @@ PROTOTYPE ERROR_CLASS Get_elements(STATUS status, DATATYPE datatype, COUNT_OUT c
 
     ret = ompi_datatype_get_elements (datatype, status->_ucount, &internal_count);
     if (OMPI_SUCCESS == ret || OMPI_ERR_VALUE_OUT_OF_BOUNDS == ret) {
-        if (OMPI_SUCCESS == ret && internal_count <= INT_MAX) {
+        /* check if value fits if compiling the legacy int API */
+        if (OMPI_SUCCESS == ret && (internal_count <= INT_MAX || sizeof(*count) > sizeof(int))) {
             *count = internal_count;
         } else {
             /* If we have more elements that we can represent with a signed int then we must
diff --git a/ompi/mpi/c/get_notify.c.in b/ompi/mpi/c/get_notify.c.in
new file mode 100644
index 00000000000..6191eceaac2
--- /dev/null
+++ b/ompi/mpi/c/get_notify.c.in
@@ -0,0 +1,81 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2015      Los Alamos National Security, LLC.  All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+#include <stdio.h>
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/runtime/ompi_spc.h"
+
+PROTOTYPE ERROR_CLASS get_notify(BUFFER_OUT origin_addr, COUNT origin_count,
+                          DATATYPE origin_datatype, INT target_rank,
+                          AINT target_disp, COUNT target_count,
+                          DATATYPE target_datatype, INT notification_idx, WIN win)
+{
+    int rc;
+
+    SPC_RECORD(OMPI_SPC_GET_NOTIFY, 1);
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_get_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) return MPI_SUCCESS;
+
+    rc = win->w_osc_module->osc_get_notify(origin_addr, origin_count, origin_datatype,
+                                    target_rank, target_disp, target_count,
+                                    target_datatype, notification_idx, win);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/neighbor_alltoallw_init.c b/ompi/mpi/c/neighbor_alltoallw_init.c
index 808fc77a2f1..3dc57c8fd9e 100644
--- a/ompi/mpi/c/neighbor_alltoallw_init.c
+++ b/ompi/mpi/c/neighbor_alltoallw_init.c
@@ -38,7 +38,7 @@
 #include "ompi/runtime/ompi_spc.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Neighbor_alltoallw_init = PMPI_Neighbor_alltoallw_init
 #endif
 #define MPI_Neighbor_alltoallw_init PMPI_Neighbor_alltoallw_init
diff --git a/ompi/mpi/c/pack.c.in b/ompi/mpi/c/pack.c.in
index 69a0bb358eb..18114c6d187 100644
--- a/ompi/mpi/c/pack.c.in
+++ b/ompi/mpi/c/pack.c.in
@@ -90,7 +90,7 @@ PROTOTYPE ERROR_CLASS pack(BUFFER inbuf, COUNT incount, DATATYPE datatype,
 
     /* Check for truncation */
     opal_convertor_get_packed_size( &local_convertor, &size );
-    if( (*position + size) > (unsigned int)outsize ) {  /* we can cast as we already checked for < 0 */
+    if( (*position + size) > (size_t)outsize ) {  /* we can cast as we already checked for < 0 */
         OBJ_DESTRUCT( &local_convertor );
         return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_TRUNCATE, FUNC_NAME);
     }
diff --git a/ompi/mpi/c/pack_size.c.in b/ompi/mpi/c/pack_size.c.in
index f0931d00671..ffaac48d0cb 100644
--- a/ompi/mpi/c/pack_size.c.in
+++ b/ompi/mpi/c/pack_size.c.in
@@ -60,7 +60,7 @@ PROTOTYPE ERROR_CLASS pack_size(COUNT incount, DATATYPE datatype, COMM comm,
                                               incount, NULL, 0, &local_convertor );
 
     opal_convertor_get_packed_size( &local_convertor, &length );
-    *size = (int)length;
+    *size = length;
     OBJ_DESTRUCT( &local_convertor );
 
     return MPI_SUCCESS;
diff --git a/ompi/mpi/c/parrived.c.in b/ompi/mpi/c/parrived.c.in
index 562138ef1ca..0f3e5af5e69 100644
--- a/ompi/mpi/c/parrived.c.in
+++ b/ompi/mpi/c/parrived.c.in
@@ -45,7 +45,20 @@ PROTOTYPE ERROR_CLASS parrived(REQUEST request, INT partition, INT_OUT flag)
         rc = OMPI_SUCCESS;
 
         OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-        if (NULL == request || OMPI_REQUEST_PART != request->req_type) {
+        // MPI-5.0 sec 4.2.2 (p.119): MPI_Parrived on a null or inactive
+        // request returns flag = true.  Handle these before the
+        // request-type check so MPI_REQUEST_NULL (req_type ==
+        // OMPI_REQUEST_NULL) and a never-started inactive partitioned
+        // receive request are not rejected with MPI_ERR_REQUEST.
+        if (NULL == request || MPI_REQUEST_NULL == request) {
+            *flag = 1;
+            return MPI_SUCCESS;
+        }
+        if (OMPI_REQUEST_INACTIVE == request->req_state) {
+            *flag = 1;
+            return MPI_SUCCESS;
+        }
+        if (OMPI_REQUEST_PART != request->req_type) {
             rc = MPI_ERR_REQUEST;
         }
         OMPI_ERRHANDLER_CHECK(rc, MPI_COMM_WORLD, rc, FUNC_NAME);
diff --git a/ompi/mpi/c/pcontrol.c b/ompi/mpi/c/pcontrol.c
index 7aba846cce0..f4b7ca847da 100644
--- a/ompi/mpi/c/pcontrol.c
+++ b/ompi/mpi/c/pcontrol.c
@@ -25,7 +25,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Pcontrol = PMPI_Pcontrol
 #endif
 #define MPI_Pcontrol PMPI_Pcontrol
diff --git a/ompi/mpi/c/pready_list.c.in b/ompi/mpi/c/pready_list.c.in
index 086ff618954..d781514eb83 100644
--- a/ompi/mpi/c/pready_list.c.in
+++ b/ompi/mpi/c/pready_list.c.in
@@ -38,7 +38,8 @@
 PROTOTYPE ERROR_CLASS pready_list(INT length, INT_ARRAY partitions, REQUEST request)
 {
     int rc = OMPI_SUCCESS;
-    SPC_RECORD(OMPI_SPC_PREADY, 1);
+
+    SPC_RECORD(OMPI_SPC_PREADY_LIST, 1);
 
     if (MPI_PARAM_CHECK) {
         rc = OMPI_SUCCESS;
diff --git a/ompi/mpi/c/pready_range.c.in b/ompi/mpi/c/pready_range.c.in
index 7dfc2df59ae..1cc962198a8 100644
--- a/ompi/mpi/c/pready_range.c.in
+++ b/ompi/mpi/c/pready_range.c.in
@@ -39,7 +39,7 @@ PROTOTYPE ERROR_CLASS pready_range(INT partition_low, INT partition_high, REQUES
 {
     int rc;
 
-    SPC_RECORD(OMPI_SPC_PREADY, 1);
+    SPC_RECORD(OMPI_SPC_PREADY_RANGE, 1);
 
     if (MPI_PARAM_CHECK) {
         rc = OMPI_SUCCESS;
diff --git a/ompi/mpi/c/precv_init.c.in b/ompi/mpi/c/precv_init.c.in
index 31b1f3d97f8..ea7224fe936 100644
--- a/ompi/mpi/c/precv_init.c.in
+++ b/ompi/mpi/c/precv_init.c.in
@@ -42,6 +42,8 @@ PROTOTYPE ERROR_CLASS precv_init(BUFFER_OUT buf, INT partitions, PARTITIONED_COU
 {
     int rc;
 
+    SPC_RECORD(OMPI_SPC_PRECV_INIT, 1);
+
     if (MPI_PARAM_CHECK) {
         rc = OMPI_SUCCESS;
 
diff --git a/ompi/mpi/c/psend_init.c.in b/ompi/mpi/c/psend_init.c.in
index 7ddf8335090..5458062008b 100644
--- a/ompi/mpi/c/psend_init.c.in
+++ b/ompi/mpi/c/psend_init.c.in
@@ -42,6 +42,8 @@ PROTOTYPE ERROR_CLASS psend_init(BUFFER buf, INT partitions, PARTITIONED_COUNT c
 {
     int rc;
 
+    SPC_RECORD(OMPI_SPC_PSEND_INIT, 1);
+
     if (MPI_PARAM_CHECK) {
         rc = OMPI_SUCCESS;
 
diff --git a/ompi/mpi/c/put_notify.c.in b/ompi/mpi/c/put_notify.c.in
new file mode 100644
index 00000000000..0141725c322
--- /dev/null
+++ b/ompi/mpi/c/put_notify.c.in
@@ -0,0 +1,84 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2013-2015 Los Alamos National Security, LLC.  All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+#include <stdio.h>
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/runtime/ompi_spc.h"
+
+PROTOTYPE ERROR_CLASS put_notify(BUFFER origin_addr, COUNT origin_count, DATATYPE origin_datatype,
+                          INT target_rank, AINT target_disp, COUNT target_count,
+                          DATATYPE target_datatype, INT notification_idx, WIN win)
+{
+    int rc;
+
+    SPC_RECORD(OMPI_SPC_PUT_NOTIFY, 1);
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if (NULL == target_datatype ||
+                   MPI_DATATYPE_NULL == target_datatype) {
+            rc = MPI_ERR_TYPE;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_put_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) return MPI_SUCCESS;
+
+    rc = win->w_osc_module->osc_put_notify(origin_addr, origin_count, origin_datatype,
+                                    target_rank, target_disp, target_count,
+                                    target_datatype, notification_idx, win);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/raccumulate_notify.c.in b/ompi/mpi/c/raccumulate_notify.c.in
new file mode 100644
index 00000000000..c9df87b74bc
--- /dev/null
+++ b/ompi/mpi/c/raccumulate_notify.c.in
@@ -0,0 +1,143 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2009      Sun Microsystmes, Inc.  All rights reserved.
+ * Copyright (c) 2011      Sandia National Laboratories. All rights reserved.
+ * Copyright (c) 2014-2015 Los Alamos National Security, LLC. All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+#include <stdio.h>
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/request/request.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/op/op.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/datatype/ompi_datatype_internal.h"
+#include "ompi/memchecker.h"
+
+PROTOTYPE ERROR_CLASS raccumulate_notify(BUFFER origin_addr, COUNT origin_count, DATATYPE origin_datatype,
+                                         INT target_rank, AINT target_disp, COUNT target_count,
+                                         DATATYPE target_datatype, OP op, INT notification_idx,
+                                         WIN win, REQUEST_INOUT request)
+{
+    int rc;
+    ompi_win_t *ompi_win = (ompi_win_t*) win;
+
+    MEMCHECKER(
+        memchecker_datatype(origin_datatype);
+        memchecker_datatype(target_datatype);
+        memchecker_call(&opal_memchecker_base_isdefined, (void *) origin_addr, origin_count, origin_datatype);
+    );
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if (MPI_OP_NULL == op || MPI_NO_OP == op) {
+            rc = MPI_ERR_OP;
+        } else if (!ompi_op_is_intrinsic(op)) {
+            rc = MPI_ERR_OP;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            /* The upper bound depends on how many counters the *target* has
+               attached, which only the osc module can see, so the range check
+               proper happens there. */
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+            if (OMPI_SUCCESS == rc) {
+                /* While technically the standard probably requires that the
+                   datatypes used with MPI_REPLACE conform to all the rules
+                   for other reduction operators, we don't require such
+                   behavior, as checking for it is expensive here and we don't
+                   care in implementation.. */
+                if (op != &ompi_mpi_op_replace.op && op != &ompi_mpi_op_no_op.op) {
+                    ompi_datatype_t *op_check_dt, *origin_check_dt;
+                    char *msg;
+
+                    /* ACCUMULATE, unlike REDUCE, can use with derived
+                       datatypes with predefinied operations, with some
+                       restrictions outlined in MPI-3:11.3.4.  The derived
+                       datatype must be composed entirely from one predefined
+                       datatype (so you can do all the construction you want,
+                       but at the bottom, you can only use one datatype, say,
+                       MPI_INT).  If the datatype at the target isn't
+                       predefined, then make sure it's composed of only one
+                       datatype, and check that datatype against
+                       ompi_op_is_valid(). */
+                    origin_check_dt = ompi_datatype_get_single_predefined_type_from_args(origin_datatype);
+                    op_check_dt = ompi_datatype_get_single_predefined_type_from_args(target_datatype);
+
+                    if( !((origin_check_dt == op_check_dt) & (NULL != op_check_dt)) ) {
+                        OMPI_ERRHANDLER_RETURN(MPI_ERR_ARG, win, MPI_ERR_ARG, FUNC_NAME);
+                    }
+
+                    /* check to make sure primitive type is valid for
+                       reduction.  Should do this on the target, but
+                       then can't get the errcode back for this
+                       call */
+                    if (!ompi_op_is_valid(op, op_check_dt, &msg, FUNC_NAME)) {
+                        int ret = OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_OP, msg);
+                        free(msg);
+                        return ret;
+                    }
+                }
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_raccumulate_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) {
+        *request = &ompi_request_empty;
+        return MPI_SUCCESS;
+    }
+
+    rc = ompi_win->w_osc_module->osc_raccumulate_notify(origin_addr,
+                                                        origin_count,
+                                                        origin_datatype,
+                                                        target_rank,
+                                                        target_disp,
+                                                        target_count,
+                                                        target_datatype,
+                                                        op, notification_idx, win, request);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/rget_accumulate_notify.c.in b/ompi/mpi/c/rget_accumulate_notify.c.in
new file mode 100644
index 00000000000..f3466f5fb0b
--- /dev/null
+++ b/ompi/mpi/c/rget_accumulate_notify.c.in
@@ -0,0 +1,152 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2009      Sun Microsystmes, Inc.  All rights reserved.
+ * Copyright (c) 2011      Sandia National Laboratories. All rights reserved.
+ * Copyright (c) 2014-2015 Los Alamos National Security, LLC. All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+#include <stdio.h>
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/request/request.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/op/op.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/datatype/ompi_datatype_internal.h"
+#include "ompi/memchecker.h"
+
+PROTOTYPE ERROR_CLASS rget_accumulate_notify(BUFFER origin_addr, COUNT origin_count, DATATYPE origin_datatype,
+                                             BUFFER_OUT result_addr, COUNT result_count, DATATYPE result_datatype,
+                                             INT target_rank, AINT target_disp, COUNT target_count,
+                                             DATATYPE target_datatype, OP op, INT notification_idx,
+                                             WIN win, REQUEST_INOUT request)
+{
+    int rc;
+    ompi_win_t *ompi_win = (ompi_win_t*) win;
+
+    MEMCHECKER(
+        memchecker_datatype(origin_datatype);
+        memchecker_datatype(target_datatype);
+        memchecker_call(&opal_memchecker_base_isdefined, (void *) origin_addr, origin_count, origin_datatype);
+    );
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if (MPI_OP_NULL == op) {
+            rc = MPI_ERR_OP;
+        } else if (!ompi_op_is_intrinsic(op)) {
+            rc = MPI_ERR_OP;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            /* The upper bound depends on how many counters the *target* has
+               attached, which only the osc module can see, so the range check
+               proper happens there. */
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            /* the origin datatype is meaningless when using MPI_OP_NO_OP */
+            if (&ompi_mpi_op_no_op.op != op) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            } else {
+                rc = OMPI_SUCCESS;
+            }
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+            if (OMPI_SUCCESS == rc) {
+                /* While technically the standard probably requires that the
+                   datatypes used with MPI_REPLACE conform to all the rules
+                   for other reduction operators, we don't require such
+                   behavior, as checking for it is expensive here and we don't
+                   care in implementation.. */
+                if (op != &ompi_mpi_op_replace.op && op != &ompi_mpi_op_no_op.op) {
+                    ompi_datatype_t *op_check_dt, *origin_check_dt;
+                    char *msg;
+
+                    /* GET_ACCUMULATE, unlike REDUCE, can use with derived
+                       datatypes with predefinied operations, with some
+                       restrictions outlined in MPI-3:11.3.4.  The derived
+                       datatype must be composed entirely from one predefined
+                       datatype (so you can do all the construction you want,
+                       but at the bottom, you can only use one datatype, say,
+                       MPI_INT).  If the datatype at the target isn't
+                       predefined, then make sure it's composed of only one
+                       datatype, and check that datatype against
+                       ompi_op_is_valid(). */
+                    origin_check_dt = ompi_datatype_get_single_predefined_type_from_args(origin_datatype);
+                    op_check_dt = ompi_datatype_get_single_predefined_type_from_args(target_datatype);
+
+                    if( !((origin_check_dt == op_check_dt) & (NULL != op_check_dt)) ) {
+                        OMPI_ERRHANDLER_RETURN(MPI_ERR_ARG, win, MPI_ERR_ARG, FUNC_NAME);
+                    }
+
+                    /* check to make sure primitive type is valid for
+                       reduction.  Should do this on the target, but
+                       then can't get the errcode back for this
+                       call */
+                    if (!ompi_op_is_valid(op, op_check_dt, &msg, FUNC_NAME)) {
+                        int ret = OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_OP, msg);
+                        free(msg);
+                        return ret;
+                    }
+                }
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_rget_accumulate_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) {
+        *request = &ompi_request_empty;
+        return MPI_SUCCESS;
+    }
+
+    rc = ompi_win->w_osc_module->osc_rget_accumulate_notify(origin_addr,
+                                                            origin_count,
+                                                            origin_datatype,
+                                                            result_addr,
+                                                            result_count,
+                                                            result_datatype,
+                                                            target_rank,
+                                                            target_disp,
+                                                            target_count,
+                                                            target_datatype,
+                                                            op, notification_idx, win, request);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/rget_notify.c.in b/ompi/mpi/c/rget_notify.c.in
new file mode 100644
index 00000000000..1241a84128a
--- /dev/null
+++ b/ompi/mpi/c/rget_notify.c.in
@@ -0,0 +1,93 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2013-2015 Los Alamos National Security, LLC.  All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+#include <stdio.h>
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/request/request.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/runtime/ompi_spc.h"
+
+PROTOTYPE ERROR_CLASS rget_notify(BUFFER_OUT origin_addr, COUNT origin_count, DATATYPE origin_datatype,
+                                  INT target_rank, AINT target_disp, COUNT target_count,
+                                  DATATYPE target_datatype, INT notification_idx, WIN win,
+                                  REQUEST_INOUT request)
+{
+    int rc;
+
+    SPC_RECORD(OMPI_SPC_RGET_NOTIFY, 1);
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if (NULL == target_datatype ||
+                   MPI_DATATYPE_NULL == target_datatype) {
+            rc = MPI_ERR_TYPE;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            /* The upper bound depends on how many counters the *target* has
+               attached, which only the osc module can see, so the range check
+               proper happens there. */
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_rget_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) {
+        *request = &ompi_request_empty;
+        return MPI_SUCCESS;
+    }
+
+    rc = win->w_osc_module->osc_rget_notify(origin_addr, origin_count, origin_datatype,
+                                            target_rank, target_disp, target_count,
+                                            target_datatype, notification_idx, win,
+                                            request);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/rput_notify.c.in b/ompi/mpi/c/rput_notify.c.in
new file mode 100644
index 00000000000..621bfadb10b
--- /dev/null
+++ b/ompi/mpi/c/rput_notify.c.in
@@ -0,0 +1,93 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2020 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2006      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2013-2015 Los Alamos National Security, LLC.  All rights
+ *                         reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+#include <stdio.h>
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/communicator/communicator.h"
+#include "ompi/request/request.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/runtime/ompi_spc.h"
+
+PROTOTYPE ERROR_CLASS rput_notify(BUFFER origin_addr, COUNT origin_count, DATATYPE origin_datatype,
+                                  INT target_rank, AINT target_disp, COUNT target_count,
+                                  DATATYPE target_datatype, INT notification_idx, WIN win,
+                                  REQUEST_INOUT request)
+{
+    int rc;
+
+    SPC_RECORD(OMPI_SPC_RPUT_NOTIFY, 1);
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (origin_count < 0 || target_count < 0) {
+            rc = MPI_ERR_COUNT;
+        } else if (ompi_win_peer_invalid(win, target_rank) &&
+                   (MPI_PROC_NULL != target_rank)) {
+            rc = MPI_ERR_RANK;
+        } else if (NULL == target_datatype ||
+                   MPI_DATATYPE_NULL == target_datatype) {
+            rc = MPI_ERR_TYPE;
+        } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) {
+            rc = MPI_ERR_DISP;
+        } else if (notification_idx < 0) {
+            /* The upper bound depends on how many counters the *target* has
+               attached, which only the osc module can see, so the range check
+               proper happens there. */
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else {
+            OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, origin_datatype, origin_count);
+            if (OMPI_SUCCESS == rc) {
+                OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, target_datatype, target_count);
+            }
+        }
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_rput_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    if (MPI_PROC_NULL == target_rank) {
+        *request = &ompi_request_empty;
+        return MPI_SUCCESS;
+    }
+
+    rc = win->w_osc_module->osc_rput_notify(origin_addr, origin_count, origin_datatype,
+                                            target_rank, target_disp, target_count,
+                                            target_datatype, notification_idx, win,
+                                            request);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/type_contiguous.c.in b/ompi/mpi/c/type_contiguous.c.in
index cc88f3cab77..853f12cc9ca 100644
--- a/ompi/mpi/c/type_contiguous.c.in
+++ b/ompi/mpi/c/type_contiguous.c.in
@@ -17,6 +17,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -32,11 +33,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
-
 
 PROTOTYPE ERROR_CLASS type_contiguous(COUNT count,
                                       DATATYPE oldtype,
@@ -56,12 +52,6 @@ PROTOTYPE ERROR_CLASS type_contiguous(COUNT count,
         } else if( count < 0 ) {
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_COUNT, FUNC_NAME);
         }
-#if OMPI_BIGCOUNT_SRC
-        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
-        if (OMPI_SUCCESS != rc) {
-            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-        }
-#endif
     }
 
     rc = ompi_datatype_create_contiguous( count, oldtype, newtype );
@@ -69,13 +59,14 @@ PROTOTYPE ERROR_CLASS type_contiguous(COUNT count,
 
     /* data description */
     {
+        ompi_count_array_t a_i[1] = {OMPI_COUNT_ARRAY_CREATE(&count)};
 #if OMPI_BIGCOUNT_SRC
-        int icount = (int)count;
-        const int* a_i[1] = {&icount};
-#else
-        const int* a_i[1] = {&count};
-#endif
-        ompi_datatype_set_args( *newtype, 1, a_i, 0, NULL, 1, &oldtype, MPI_COMBINER_CONTIGUOUS );
+        ompi_datatype_set_args( *newtype, 0, 1,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype, MPI_COMBINER_CONTIGUOUS );
+#else  // OMPI_BIGCOUNT_SRC
+        ompi_datatype_set_args( *newtype, 1, 0,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype, MPI_COMBINER_CONTIGUOUS );
+#endif // OMPI_BIGCOUNT_SRC
     }
 
     OMPI_ERRHANDLER_NOHANDLE_RETURN(rc, rc, FUNC_NAME );
diff --git a/ompi/mpi/c/type_create_darray.c.in b/ompi/mpi/c/type_create_darray.c.in
index fcf00c8fe14..bbf2114d067 100644
--- a/ompi/mpi/c/type_create_darray.c.in
+++ b/ompi/mpi/c/type_create_darray.c.in
@@ -17,6 +17,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -33,11 +34,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
-
 
 PROTOTYPE ERROR_CLASS type_create_darray(INT size,
                                          INT rank,
@@ -51,7 +47,6 @@ PROTOTYPE ERROR_CLASS type_create_darray(INT size,
                                          DATATYPE_OUT newtype)
 {
     int i, rc;
-    int *igsize_array = NULL;
 
     MEMCHECKER(
         memchecker_datatype(oldtype);
@@ -75,14 +70,6 @@ PROTOTYPE ERROR_CLASS type_create_darray(INT size,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG, FUNC_NAME);
         }
         if( ndims > 0 ) {
-#if OMPI_BIGCOUNT_SRC
-            for( i = 0; i < ndims; i++ ) {
-                OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, gsize_array[i]);
-                if (OMPI_SUCCESS != rc) {
-                    return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-                }
-            }
-#endif
             for( i = 0; i < ndims; i++ ) {
                 if( (MPI_DISTRIBUTE_BLOCK != distrib_array[i]) &&
                     (MPI_DISTRIBUTE_CYCLIC != distrib_array[i]) &&
@@ -104,30 +91,32 @@ PROTOTYPE ERROR_CLASS type_create_darray(INT size,
         }
     }
 
-#if OMPI_BIGCOUNT_SRC
-    igsize_array = (int *)malloc(ndims * sizeof(int));
-    if (NULL == igsize_array) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    for (int ii=0;ii<ndims;ii++) {
-        igsize_array[ii] = (int)gsize_array[ii];
-    }
-#else
-    igsize_array = (int *)gsize_array;
-#endif
+    ompi_count_array_t cgsize_array = OMPI_COUNT_ARRAY_CREATE(gsize_array);
     rc = ompi_datatype_create_darray( size, rank, ndims,
-                                      igsize_array, distrib_array, darg_array, psize_array,
+                                      cgsize_array, distrib_array, darg_array, psize_array,
                                       order, oldtype, newtype );
-    if( OMPI_SUCCESS == rc ) {
-        const int* a_i[8] = {&size, &rank, &ndims, igsize_array, distrib_array, darg_array,
-                             psize_array, &order};
 
-        ompi_datatype_set_args( *newtype, 4 * ndims + 4, a_i, 0, NULL, 1, &oldtype,
+    if( OMPI_SUCCESS == rc ) {
+        ompi_count_array_t a_i[8] = {OMPI_COUNT_ARRAY_CREATE(&size),
+                                     OMPI_COUNT_ARRAY_CREATE(&rank),
+                                     OMPI_COUNT_ARRAY_CREATE(&ndims),
+                                     cgsize_array,
+                                     OMPI_COUNT_ARRAY_CREATE(distrib_array),
+                                     OMPI_COUNT_ARRAY_CREATE(darg_array),
+                                     OMPI_COUNT_ARRAY_CREATE(psize_array),
+                                     OMPI_COUNT_ARRAY_CREATE(&order)};
+        size_t ci, cl;
+        if (sizeof(*gsize_array) == 8) {
+            // big count
+            ci = 3 * ndims + 4;
+            cl = ndims;
+        } else {
+            ci = 4*ndims + 4;
+            cl = 0;
+        }
+        ompi_datatype_set_args( *newtype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype,
                                 MPI_COMBINER_DARRAY );
     }
-#if OMPI_BIGCOUNT_SRC
-    free(igsize_array);
-#endif
 
     OMPI_ERRHANDLER_NOHANDLE_RETURN(rc, rc, FUNC_NAME);
 }
diff --git a/ompi/mpi/c/type_create_f90_complex.c.in b/ompi/mpi/c/type_create_f90_complex.c.in
index b5b9713872b..7aa318bb22d 100644
--- a/ompi/mpi/c/type_create_f90_complex.c.in
+++ b/ompi/mpi/c/type_create_f90_complex.c.in
@@ -21,6 +21,7 @@
  * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -84,7 +85,6 @@ PROTOTYPE ERROR_CLASS Type_create_f90_complex(INT p, INT r, DATATYPE_OUT newtype
 
     if( *newtype != &ompi_mpi_datatype_null.dt ) {
         ompi_datatype_t* datatype;
-        const int* a_i[2];
         int rc;
 
         key = (((uint64_t)p_key) << 32) | ((uint64_t)r_key);
@@ -107,9 +107,8 @@ PROTOTYPE ERROR_CLASS Type_create_f90_complex(INT p, INT r, DATATYPE_OUT newtype
         snprintf(datatype->name, sizeof(datatype->name),
                  "COMBINER %s", (*newtype)->name);
 
-        a_i[0] = &p;
-        a_i[1] = &r;
-        ompi_datatype_set_args( datatype, 2, a_i, 0, NULL, 0, NULL, MPI_COMBINER_F90_COMPLEX );
+        ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&p), OMPI_COUNT_ARRAY_CREATE(&r)};
+        ompi_datatype_set_args( datatype, 2, 0, a_i, 0, OMPI_DISP_ARRAY_NULL, 0, NULL, MPI_COMBINER_F90_COMPLEX );
 
         rc = opal_hash_table_set_value_uint64( &ompi_mpi_f90_complex_hashtable, key, datatype );
         if (OMPI_SUCCESS != rc) {
diff --git a/ompi/mpi/c/type_create_f90_integer.c.in b/ompi/mpi/c/type_create_f90_integer.c.in
index 222794a9884..ff9c006936b 100644
--- a/ompi/mpi/c/type_create_f90_integer.c.in
+++ b/ompi/mpi/c/type_create_f90_integer.c.in
@@ -19,6 +19,7 @@
  * Copyright (c) 2018      Amazon.com, Inc. or its affiliates.  All Rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -75,7 +76,6 @@ PROTOTYPE ERROR_CLASS type_create_f90_integer(INT r, DATATYPE_OUT newtype)
 
     if( *newtype != &ompi_mpi_datatype_null.dt ) {
         ompi_datatype_t* datatype;
-        const int* a_i[1];
         int rc;
 
         if( OPAL_SUCCESS == opal_hash_table_get_value_uint32( &ompi_mpi_f90_integer_hashtable,
@@ -97,8 +97,8 @@ PROTOTYPE ERROR_CLASS type_create_f90_integer(INT r, DATATYPE_OUT newtype)
         snprintf(datatype->name, sizeof(datatype->name),
                  "COMBINER %s", (*newtype)->name);
 
-        a_i[0] = &r;
-        ompi_datatype_set_args( datatype, 1, a_i, 0, NULL, 0, NULL, MPI_COMBINER_F90_INTEGER );
+        ompi_count_array_t a_i[1] = {OMPI_COUNT_ARRAY_CREATE(&r)};
+        ompi_datatype_set_args( datatype, 1, 0, a_i, 0, OMPI_DISP_ARRAY_NULL, 0, NULL, MPI_COMBINER_F90_INTEGER );
 
         rc = opal_hash_table_set_value_uint32( &ompi_mpi_f90_integer_hashtable, r, datatype );
         if (OMPI_SUCCESS != rc) {
diff --git a/ompi/mpi/c/type_create_f90_real.c.in b/ompi/mpi/c/type_create_f90_real.c.in
index e7d2e28bde9..54566ba5671 100644
--- a/ompi/mpi/c/type_create_f90_real.c.in
+++ b/ompi/mpi/c/type_create_f90_real.c.in
@@ -21,6 +21,7 @@
  * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -84,7 +85,6 @@ PROTOTYPE ERROR_CLASS type_create_f90_real(INT p, INT r, DATATYPE_OUT newtype)
 
     if( *newtype != &ompi_mpi_datatype_null.dt ) {
         ompi_datatype_t* datatype;
-        const int* a_i[2] = {&p, &r};
         int rc;
 
         key = (((uint64_t)p_key) << 32) | ((uint64_t)r_key);
@@ -107,7 +107,8 @@ PROTOTYPE ERROR_CLASS type_create_f90_real(INT p, INT r, DATATYPE_OUT newtype)
         snprintf(datatype->name, sizeof(datatype->name),
                  "COMBINER %s", (*newtype)->name);
 
-        ompi_datatype_set_args( datatype, 2, a_i, 0, NULL, 0, NULL, MPI_COMBINER_F90_REAL );
+        ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&p), OMPI_COUNT_ARRAY_CREATE(&r)};
+        ompi_datatype_set_args( datatype, 2, 0, a_i, 0, OMPI_DISP_ARRAY_NULL, 0, NULL, MPI_COMBINER_F90_REAL );
 
         rc = opal_hash_table_set_value_uint64( &ompi_mpi_f90_real_hashtable, key, datatype );
         if (OMPI_SUCCESS != rc) {
diff --git a/ompi/mpi/c/type_create_hindexed.c.in b/ompi/mpi/c/type_create_hindexed.c.in
index 79e03f91bb2..bd8cdf6f4cf 100644
--- a/ompi/mpi/c/type_create_hindexed.c.in
+++ b/ompi/mpi/c/type_create_hindexed.c.in
@@ -16,6 +16,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -33,12 +34,6 @@
 #include "ompi/memchecker.h"
 
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
-
-
 PROTOTYPE ERROR_CLASS type_create_hindexed(COUNT count,
                                            COUNT_ARRAY array_of_blocklengths,
                                            AINT_COUNT_ARRAY array_of_displacements,
@@ -46,8 +41,6 @@ PROTOTYPE ERROR_CLASS type_create_hindexed(COUNT count,
                                            DATATYPE_OUT newtype)
 {
     int rc, i;
-    int *iarray_of_blocklengths = NULL;
-    MPI_Aint *iarray_of_displacements = NULL;
 
     MEMCHECKER(
         memchecker_datatype(oldtype);
@@ -73,34 +66,14 @@ PROTOTYPE ERROR_CLASS type_create_hindexed(COUNT count,
                                               FUNC_NAME );
             }
         }
-#if OMPI_BIGCOUNT_SRC
-        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
-        if (OMPI_SUCCESS != rc) {
-            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-        }
-#endif
-    }
-
-#if OMPI_BIGCOUNT_SRC
-    iarray_of_blocklengths = (int *)malloc(count * sizeof(int));
-    if (NULL == iarray_of_blocklengths) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
     }
-    iarray_of_displacements = (MPI_Aint *)malloc(count * sizeof(MPI_Aint));
-    if (NULL == iarray_of_displacements) {
-        free( iarray_of_blocklengths);
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    for (i = 0; i < (int)count; i++) {
-        iarray_of_blocklengths[i] = (int)array_of_blocklengths[i];
-        iarray_of_displacements[i] = (MPI_Aint)array_of_displacements[i];
-    }
-#else
-    iarray_of_blocklengths = (int *)array_of_blocklengths;
-    iarray_of_displacements = (MPI_Aint *)array_of_displacements;
-#endif
 
-    rc = ompi_datatype_create_hindexed( count, iarray_of_blocklengths, iarray_of_displacements,
+    /*
+     * TODO: array_of_displacements can be either MPI_Aint or MPI_Count.
+     *       The call below takes a ompi_disp_array_t which maps to MPI_Aint.
+     */
+    rc = ompi_datatype_create_hindexed( count, OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths),
+                                        OMPI_DISP_ARRAY_CREATE(array_of_displacements),
                                         oldtype, newtype );
     if( rc != MPI_SUCCESS ) {
         ompi_datatype_destroy( newtype );
@@ -108,15 +81,22 @@ PROTOTYPE ERROR_CLASS type_create_hindexed(COUNT count,
     }
     /* data description */
     {
-        const int* a_i[2] = {(int *)&count, iarray_of_blocklengths};
+#if OMPI_BIGCOUNT_SRC
+        ompi_count_array_t a_i[3] = {
+                    OMPI_COUNT_ARRAY_CREATE(&count),
+                    OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths),
+                    OMPI_COUNT_ARRAY_CREATE(array_of_displacements)};
 
-        ompi_datatype_set_args( *newtype, count + 1, a_i, count, iarray_of_displacements,
+        ompi_datatype_set_args( *newtype, 0, 2*count + 1,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL,
                                 1, &oldtype, MPI_COMBINER_HINDEXED );
+#else
+        ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&count), OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths)};
+        ompi_datatype_set_args( *newtype, count + 1, 0,
+                                a_i, count, OMPI_DISP_ARRAY_CREATE(array_of_displacements),
+                                1, &oldtype, MPI_COMBINER_HINDEXED );
+#endif
     }
 
-#if OMPI_BIGCOUNT_SRC
-    free(iarray_of_blocklengths);
-    free(iarray_of_displacements);
-#endif
     return MPI_SUCCESS;
 }
diff --git a/ompi/mpi/c/type_create_hindexed_block.c.in b/ompi/mpi/c/type_create_hindexed_block.c.in
index f7bbadd3631..0fea130d1a5 100644
--- a/ompi/mpi/c/type_create_hindexed_block.c.in
+++ b/ompi/mpi/c/type_create_hindexed_block.c.in
@@ -9,6 +9,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -25,10 +26,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
 
 PROTOTYPE ERROR_CLASS type_create_hindexed_block(COUNT count,
                                                  COUNT blocklength,
@@ -37,7 +34,6 @@ PROTOTYPE ERROR_CLASS type_create_hindexed_block(COUNT count,
                                                  DATATYPE_OUT newtype)
 {
     int rc;
-    MPI_Aint *iarray_of_displacements = NULL;
 
     MEMCHECKER(
         memchecker_datatype(oldtype);
@@ -56,40 +52,32 @@ PROTOTYPE ERROR_CLASS type_create_hindexed_block(COUNT count,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_TYPE,
                                           FUNC_NAME );
         }
-#if OMPI_BIGCOUNT_SRC
-        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
-        if (OMPI_SUCCESS != rc) {
-            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-        }
-#endif
-    }
-
-#if OMPI_BIGCOUNT_SRC
-    iarray_of_displacements = (MPI_Aint *)malloc(count * sizeof(MPI_Aint));
-    if (NULL == iarray_of_displacements) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    for (int ii = 0; ii < (int)count; ii++) {
-        iarray_of_displacements[ii] = (MPI_Aint)array_of_displacements[ii];
     }
-#else
-    iarray_of_displacements = (MPI_Aint *)array_of_displacements;
-#endif
 
-    rc = ompi_datatype_create_hindexed_block( count, blocklength, iarray_of_displacements,
+    rc = ompi_datatype_create_hindexed_block( count, blocklength, OMPI_DISP_ARRAY_CREATE(array_of_displacements),
                                               oldtype, newtype );
     if( rc != MPI_SUCCESS ) {
         ompi_datatype_destroy( newtype );
         OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, rc, FUNC_NAME );
     }
     {
-        const int* a_i[2] = {(int *)&count, (int *)&blocklength};
-        ompi_datatype_set_args( *newtype, 2, a_i, count, iarray_of_displacements, 1, &oldtype,
-                                MPI_COMBINER_HINDEXED_BLOCK );
-    }
 #if OMPI_BIGCOUNT_SRC
-    free(iarray_of_displacements);
+        ompi_count_array_t a_i[3] = {
+                    OMPI_COUNT_ARRAY_CREATE(&count),
+                    OMPI_COUNT_ARRAY_CREATE(&blocklength),
+                    OMPI_COUNT_ARRAY_CREATE(array_of_displacements)};
+        ompi_datatype_set_args( *newtype, 0, count + 2,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL,
+                                1, &oldtype,
+                                MPI_COMBINER_HINDEXED_BLOCK );
+#else
+        ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&count), OMPI_COUNT_ARRAY_CREATE(&blocklength)};
+
+        ompi_datatype_set_args( *newtype, 2, 0,
+                                a_i, count, OMPI_DISP_ARRAY_CREATE(array_of_displacements), 1, &oldtype,
+                                MPI_COMBINER_HINDEXED_BLOCK );
 #endif
+    }
 
     return MPI_SUCCESS;
 }
diff --git a/ompi/mpi/c/type_create_hvector.c.in b/ompi/mpi/c/type_create_hvector.c.in
index cb93050d05c..537b7c772f3 100644
--- a/ompi/mpi/c/type_create_hvector.c.in
+++ b/ompi/mpi/c/type_create_hvector.c.in
@@ -16,6 +16,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -32,10 +33,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
 
 PROTOTYPE ERROR_CLASS type_create_hvector(COUNT count,
                                           COUNT blocklength,
@@ -62,12 +59,6 @@ PROTOTYPE ERROR_CLASS type_create_hvector(COUNT count,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_TYPE,
                                           FUNC_NAME );
         }
-#if OMPI_BIGCOUNT_SRC
-        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
-        if (OMPI_SUCCESS != rc) {
-            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-        }
-#endif
     }
 
     rc = ompi_datatype_create_hvector ( count, blocklength, stride, oldtype,
@@ -75,10 +66,20 @@ PROTOTYPE ERROR_CLASS type_create_hvector(COUNT count,
     OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME );
 
     {
-        const int* a_i[2] = {(int *)&count, (int *)&blocklength};
-        MPI_Aint a_a[1] = {stride};
+#if OMPI_BIGCOUNT_SRC
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(&blocklength),
+                                     OMPI_COUNT_ARRAY_CREATE(&stride)};
 
-        ompi_datatype_set_args( *newtype, 2, a_i, 1, a_a, 1, &oldtype, MPI_COMBINER_HVECTOR );
+        ompi_datatype_set_args( *newtype, 0, 3,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype, MPI_COMBINER_HVECTOR );
+#else
+        const ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                           OMPI_COUNT_ARRAY_CREATE(&blocklength)};
+
+        ompi_datatype_set_args( *newtype, 2, 0,
+                                a_i, 1, OMPI_DISP_ARRAY_CREATE(&stride), 1, &oldtype, MPI_COMBINER_HVECTOR );
+#endif
     }
 
     return MPI_SUCCESS;
diff --git a/ompi/mpi/c/type_create_indexed_block.c.in b/ompi/mpi/c/type_create_indexed_block.c.in
index 24732bf5086..fae61965100 100644
--- a/ompi/mpi/c/type_create_indexed_block.c.in
+++ b/ompi/mpi/c/type_create_indexed_block.c.in
@@ -16,6 +16,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -32,11 +33,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
-
 
 PROTOTYPE ERROR_CLASS type_create_indexed_block(COUNT count,
                                                 COUNT blocklength,
@@ -45,7 +41,6 @@ PROTOTYPE ERROR_CLASS type_create_indexed_block(COUNT count,
                                                 DATATYPE_OUT newtype)
 {
     int rc;
-    int *iarray_of_displacements = NULL;
 
     MEMCHECKER(
         memchecker_datatype(oldtype);
@@ -66,32 +61,23 @@ PROTOTYPE ERROR_CLASS type_create_indexed_block(COUNT count,
         }
     }
 
-#if OMPI_BIGCOUNT_SRC
-    iarray_of_displacements = (int *)malloc(count * sizeof(int));
-    if (NULL == iarray_of_displacements) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    for (int ii = 0; ii < (int)count; ii++) {
-        iarray_of_displacements[ii] = (int)array_of_displacements[ii];
-    }
-#else
-    iarray_of_displacements = (int *)array_of_displacements;
-#endif
-    rc = ompi_datatype_create_indexed_block( count, blocklength, iarray_of_displacements,
+    rc = ompi_datatype_create_indexed_block( count, blocklength, OMPI_COUNT_ARRAY_CREATE(array_of_displacements),
                                              oldtype, newtype );
     if( rc != MPI_SUCCESS ) {
         ompi_datatype_destroy( newtype );
         OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, rc, FUNC_NAME );
     }
     {
-        const int* a_i[3] = {(int *)&count, (int *)&blocklength, iarray_of_displacements};
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(&blocklength),
+                                     OMPI_COUNT_ARRAY_CREATE(array_of_displacements)};
 
-        ompi_datatype_set_args( *newtype, 2 + count, a_i, 0, NULL, 1, &oldtype,
+        ompi_datatype_set_args( *newtype,
+                                (sizeof(count) != sizeof(size_t)) ? count + 2 : 0,
+                                (sizeof(count) == sizeof(size_t)) ? count + 2 : 0,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype,
                                 MPI_COMBINER_INDEXED_BLOCK );
     }
 
-#if OMPI_BIGCOUNT_SRC
-    free(iarray_of_displacements);
-#endif
     return MPI_SUCCESS;
 }
diff --git a/ompi/mpi/c/type_create_resized.c.in b/ompi/mpi/c/type_create_resized.c.in
index 9e07109ec7b..57d2970191a 100644
--- a/ompi/mpi/c/type_create_resized.c.in
+++ b/ompi/mpi/c/type_create_resized.c.in
@@ -13,6 +13,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -55,11 +56,25 @@ PROTOTYPE ERROR_CLASS type_create_resized(DATATYPE oldtype,
       OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, rc, FUNC_NAME );
    }
 
+   /* lb and extent are byte displacements that may apply in both memory
+    * and file contexts, so the large-count interface types them as
+    * MPI_Count rather than MPI_Aint (MPI-5.0 sec 19.2).  Store them where
+    * MPI_Type_get_contents[_c] is required to return them: in the
+    * large-count array for the _c interface (so num_addresses == 0,
+    * num_large_counts == 2), and in the address array for the classic
+    * interface (num_addresses == 2). */
    {
-      MPI_Aint a_a[2];
-      a_a[0] = lb;
-      a_a[1] = extent;
-      ompi_datatype_set_args( *newtype, 0, NULL, 2, a_a, 1, &oldtype, MPI_COMBINER_RESIZED );
+#if OMPI_BIGCOUNT_SRC
+      MPI_Count a_l[2] = {lb, extent};
+      ompi_count_array_t a_i[1] = {OMPI_COUNT_ARRAY_CREATE(a_l)};
+      ompi_datatype_set_args( *newtype, 0, 2, a_i, 0, OMPI_DISP_ARRAY_NULL,
+                              1, &oldtype, MPI_COMBINER_RESIZED );
+#else
+      MPI_Aint a_a[2] = {lb, extent};
+      ompi_datatype_set_args( *newtype, 0, 0, NULL, 2,
+                              OMPI_DISP_ARRAY_CREATE(a_a),
+                              1, &oldtype, MPI_COMBINER_RESIZED );
+#endif
    }
 
    return MPI_SUCCESS;
diff --git a/ompi/mpi/c/type_create_struct.c.in b/ompi/mpi/c/type_create_struct.c.in
index accea45f603..418753af67c 100644
--- a/ompi/mpi/c/type_create_struct.c.in
+++ b/ompi/mpi/c/type_create_struct.c.in
@@ -16,6 +16,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -32,20 +33,13 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
-
 PROTOTYPE ERROR_CLASS type_create_struct(COUNT count,
                                          COUNT_ARRAY array_of_blocklengths,
                                          AINT_COUNT_ARRAY array_of_displacements,
                                          DATATYPE_ARRAY array_of_types,
                                          DATATYPE_OUT newtype)
 {
-    int i, rc, icount = (int)count;
-    int *iarray_of_blocklengths = NULL;
-    MPI_Aint *iarray_of_displacements = NULL;
+    int i, rc;
 
     if ( count > 0 ) {
         for ( i = 0; i < count; i++ ) {
@@ -77,54 +71,37 @@ PROTOTYPE ERROR_CLASS type_create_struct(COUNT count,
                                               FUNC_NAME);
             }
         }
-#if OMPI_BIGCOUNT_SRC
-        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
-        if (OMPI_SUCCESS != rc) {
-            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-        }
-#endif
     }
 
-#if OMPI_BIGCOUNT_SRC
-    iarray_of_blocklengths = (int *)malloc(count * sizeof(int));
-    if (NULL == iarray_of_blocklengths) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    iarray_of_displacements = (MPI_Aint *)malloc(count * sizeof(MPI_Aint));
-    if (NULL == iarray_of_displacements) {
-        free(iarray_of_blocklengths);
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    for (int ii = 0; ii < (int)count; ii++) {
-        iarray_of_blocklengths[ii] = (int)array_of_blocklengths[ii];
-        iarray_of_displacements[ii] = (MPI_Aint)array_of_displacements[ii];
-    }
-#else
-    iarray_of_blocklengths = (int *)array_of_blocklengths;
-    iarray_of_displacements = (MPI_Aint *)array_of_displacements;
-#endif
-    rc = ompi_datatype_create_struct( icount, iarray_of_blocklengths, iarray_of_displacements,
+    /**
+     * TODO: The array of displacements can be either MPI_Aint or MPI_Count.
+     *       The call below takes a ompi_disp_array_t which maps to MPI_Aint.
+     */
+    rc = ompi_datatype_create_struct( count, OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths),
+                                      OMPI_DISP_ARRAY_CREATE(array_of_displacements),
                                       array_of_types, newtype );
     if( rc != MPI_SUCCESS ) {
         ompi_datatype_destroy( newtype );
-#if OMPI_BIGCOUNT_SRC
-        free(iarray_of_blocklengths);
-        free(iarray_of_displacements);
-#endif
-        OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, 
+        OMPI_ERRHANDLER_NOHANDLE_RETURN( rc,
                                 rc, FUNC_NAME );
     }
 
     {
-        const int* a_i[2] = {(int *)&icount, iarray_of_blocklengths};
-
-        ompi_datatype_set_args( *newtype, icount + 1, a_i, icount, iarray_of_displacements,
-                                icount, array_of_types, MPI_COMBINER_STRUCT );
-    }
 #if OMPI_BIGCOUNT_SRC
-    free(iarray_of_blocklengths);
-    free(iarray_of_displacements);
+        ompi_count_array_t a_i[3] = {
+                    OMPI_COUNT_ARRAY_CREATE(&count),
+                    OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths),
+                    OMPI_COUNT_ARRAY_CREATE(array_of_displacements)};
+        ompi_datatype_set_args( *newtype, 0, 2*count + 1,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL,
+                                count, array_of_types, MPI_COMBINER_STRUCT );
+#else
+        ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&count), OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths)};
+        ompi_datatype_set_args( *newtype, count + 1, 0,
+                                a_i, count, OMPI_DISP_ARRAY_CREATE(array_of_displacements),
+                                count, array_of_types, MPI_COMBINER_STRUCT );
 #endif
+    }
 
     return MPI_SUCCESS;
 }
diff --git a/ompi/mpi/c/type_create_subarray.c.in b/ompi/mpi/c/type_create_subarray.c.in
index d25cde247c4..d401fc0ed48 100644
--- a/ompi/mpi/c/type_create_subarray.c.in
+++ b/ompi/mpi/c/type_create_subarray.c.in
@@ -17,6 +17,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -33,10 +34,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
 
 PROTOTYPE ERROR_CLASS type_create_subarray(INT ndims,
                                            COUNT_ARRAY size_array,
@@ -47,9 +44,6 @@ PROTOTYPE ERROR_CLASS type_create_subarray(INT ndims,
                                            DATATYPE_OUT newtype)
 {
     int32_t i, rc;
-    int *isize_array = NULL;
-    int *isubsize_array = NULL;
-    int *istart_array = NULL;
 
     MEMCHECKER(
         memchecker_datatype(oldtype);
@@ -67,20 +61,6 @@ PROTOTYPE ERROR_CLASS type_create_subarray(INT ndims,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG, FUNC_NAME);
         }
         for( i = 0; i < ndims; i++ ) {
-#if OMPI_BIGCOUNT_SRC
-            OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, size_array[i]);
-            if (OMPI_SUCCESS != rc) {
-                return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-            }
-            OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, subsize_array[i]);
-            if (OMPI_SUCCESS != rc) {
-                return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-            }
-            OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, start_array[i]);
-            if (OMPI_SUCCESS != rc) {
-                return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-            }
-#endif
             if( (subsize_array[i] < 1) || (subsize_array[i] > size_array[i]) ) {
                 return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG, FUNC_NAME);
             } else if( (start_array[i] < 0) || (start_array[i] > (size_array[i] - subsize_array[i])) ) {
@@ -89,45 +69,26 @@ PROTOTYPE ERROR_CLASS type_create_subarray(INT ndims,
         }
     }
 
-#if OMPI_BIGCOUNT_SRC
-    isize_array = (int *)malloc(ndims * sizeof(int));
-    if (NULL == isize_array) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    isubsize_array = (int *)malloc(ndims * sizeof(int));
-    if (NULL == isubsize_array) {
-        free(isize_array);
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    istart_array = (int *)malloc(ndims * sizeof(int));
-    if (NULL == istart_array) {
-        free(isize_array);
-        free(isubsize_array);
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    for (int ii = 0; ii < ndims; ii++) {
-        isize_array[ii] = (int)size_array[ii];
-        isubsize_array[ii] = (int)subsize_array[ii];
-        istart_array[ii] = (int)start_array[ii];
-    }
-#else
-    isize_array = (int *)size_array;
-    isubsize_array = (int *)subsize_array;
-    istart_array = (int *)start_array;
-#endif
-    rc = ompi_datatype_create_subarray( ndims, isize_array, isubsize_array, istart_array,
+    rc = ompi_datatype_create_subarray( ndims, OMPI_COUNT_ARRAY_CREATE(size_array), OMPI_COUNT_ARRAY_CREATE(subsize_array),
+                                        OMPI_COUNT_ARRAY_CREATE(start_array),
                                         order, oldtype, newtype);
     if( OMPI_SUCCESS == rc ) {
-        const int* a_i[5] = {&ndims, isize_array, isubsize_array, istart_array, &order};
-
-        ompi_datatype_set_args( *newtype, 3 * ndims + 2, a_i, 0, NULL, 1, &oldtype,
+        ompi_count_array_t a_i[5] = {OMPI_COUNT_ARRAY_CREATE(&ndims),
+                                     OMPI_COUNT_ARRAY_CREATE(size_array),
+                                     OMPI_COUNT_ARRAY_CREATE(subsize_array),
+                                     OMPI_COUNT_ARRAY_CREATE(start_array),
+                                     OMPI_COUNT_ARRAY_CREATE(&order)};
+        size_t ci, cl;
+        if (sizeof(size_array[0]) == sizeof(size_t)) {
+            ci = 2;
+            cl = 3*ndims;
+        } else {
+            ci = 3*ndims + 2;
+            cl = 0;
+        }
+        ompi_datatype_set_args( *newtype, ci, cl, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype,
                                 MPI_COMBINER_SUBARRAY );
     }
 
-#if OMPI_BIGCOUNT_SRC
-    free(isize_array);
-    free(isubsize_array);
-    free(istart_array);
-#endif
     OMPI_ERRHANDLER_NOHANDLE_RETURN(rc, rc, FUNC_NAME);
 }
diff --git a/ompi/mpi/c/type_dup.c.in b/ompi/mpi/c/type_dup.c.in
index 41abec68692..d3b6a70a286 100644
--- a/ompi/mpi/c/type_dup.c.in
+++ b/ompi/mpi/c/type_dup.c.in
@@ -13,6 +13,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -52,7 +53,7 @@ PROTOTYPE ERROR_CLASS type_dup (DATATYPE type, DATATYPE_OUT newtype)
        OMPI_ERRHANDLER_NOHANDLE_RETURN( ret, ret, FUNC_NAME );
    }
 
-   ompi_datatype_set_args( *newtype, 0, NULL, 0, NULL, 1, &type, MPI_COMBINER_DUP );
+   ompi_datatype_set_args( *newtype, 0, 0, NULL, 0, OMPI_DISP_ARRAY_NULL, 1, &type, MPI_COMBINER_DUP );
 
    /* Copy all the old attributes, if there were any.  This is done
       here (vs. ompi_datatype_duplicate()) because MPI_TYPE_DUP is the
diff --git a/ompi/mpi/c/type_extent.c b/ompi/mpi/c/type_extent.c
index d56f9fa02c8..9c9edaa583d 100644
--- a/ompi/mpi/c/type_extent.c
+++ b/ompi/mpi/c/type_extent.c
@@ -35,7 +35,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_extent = PMPI_Type_extent
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/type_get_contents.c b/ompi/mpi/c/type_get_contents.c
index b2998818d5d..3f2cb5b6712 100644
--- a/ompi/mpi/c/type_get_contents.c
+++ b/ompi/mpi/c/type_get_contents.c
@@ -11,6 +11,8 @@
  *                         All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,7 +30,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_get_contents = PMPI_Type_get_contents
 #endif
 #define MPI_Type_get_contents PMPI_Type_get_contents
@@ -45,7 +47,8 @@ int MPI_Type_get_contents(MPI_Datatype mtype,
                           MPI_Aint array_of_addresses[],
                           MPI_Datatype array_of_datatypes[])
 {
-    int rc, i;
+    int rc;
+    size_t i;
     MPI_Datatype newtype;
 
     MEMCHECKER(
@@ -65,15 +68,35 @@ int MPI_Type_get_contents(MPI_Datatype mtype,
         }
     }
 
-    rc = ompi_datatype_get_args( mtype, 1, &max_integers, array_of_integers,
-                            &max_addresses, array_of_addresses,
-                            &max_datatypes, array_of_datatypes, NULL );
+    size_t ci, cl, ca, cd;
+    int32_t type;
+    rc = ompi_datatype_get_args( mtype, 0, &ci, NULL,
+                                &cl, NULL,
+                                &ca, NULL,
+                                &cd, NULL, &type );
+    if( rc != MPI_SUCCESS ) {
+        OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_INTERN,
+                                MPI_ERR_INTERN, FUNC_NAME );
+    }
+    // check that we have enough space and no large counts
+    if (cl > 0 ||
+        ci > (size_t)max_integers ||
+        ca > (size_t)max_addresses ||
+        cd > (size_t)max_datatypes) {
+        OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_TYPE,
+                                MPI_ERR_TYPE, FUNC_NAME );
+    }
+    // now get the contents
+    rc = ompi_datatype_get_args( mtype, 1, &ci, array_of_integers,
+                                &cl, NULL,
+                                &ca, array_of_addresses,
+                                &cd, array_of_datatypes, NULL );
     if( rc != MPI_SUCCESS ) {
         OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_INTERN, 
                                 MPI_ERR_INTERN, FUNC_NAME );
     }
 
-    for( i = 0; i < max_datatypes; i++ ) {
+    for( i = 0; i < cd; i++ ) {
         /* if we have a predefined datatype then we return directly a pointer to
          * the datatype, otherwise we should create a copy and give back the copy.
          */
diff --git a/ompi/mpi/c/type_get_contents_c.c b/ompi/mpi/c/type_get_contents_c.c
index 6be23ccc4c4..b36ed83131c 100644
--- a/ompi/mpi/c/type_get_contents_c.c
+++ b/ompi/mpi/c/type_get_contents_c.c
@@ -11,6 +11,8 @@
  *                         All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,7 +30,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_get_contents_c = PMPI_Type_get_contents_c
 #endif
 #define MPI_Type_get_contents_c PMPI_Type_get_contents_c
@@ -47,7 +49,8 @@ int MPI_Type_get_contents_c(MPI_Datatype mtype,
                             MPI_Count  array_of_large_counts[],
                             MPI_Datatype array_of_datatypes[])
 {
-    int rc, i;
+    int rc;
+    size_t i;
     MPI_Datatype newtype;
 
     MEMCHECKER(
@@ -67,16 +70,39 @@ int MPI_Type_get_contents_c(MPI_Datatype mtype,
         }
     }
 
-/* TODO:BIGCOUNT: Need to embiggen ompi_datatype_get_args */
-    rc = ompi_datatype_get_args( mtype, 1, (int *)&max_integers, array_of_integers,
-                            (int *)&max_addresses, array_of_addresses,
-                            (int *)&max_datatypes, array_of_datatypes, NULL );
+    size_t ci, cl, ca, cd;
+    int32_t type;
+    rc = ompi_datatype_get_args( mtype, 0, &ci, NULL,
+                                &cl, NULL,
+                                &ca, NULL,
+                                &cd, NULL, &type );
+    if( rc != MPI_SUCCESS ) {
+        OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_INTERN,
+                                MPI_ERR_INTERN, FUNC_NAME );
+    }
+    // check that we have enough space
+    if (cl > (size_t)max_large_counts ||
+        ci > (size_t)max_integers ||
+        ca > (size_t)max_addresses ||
+        cd > (size_t)max_datatypes) {
+        OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_TYPE,
+                                MPI_ERR_TYPE, FUNC_NAME );
+    }
+
+    rc = ompi_datatype_get_args( mtype, 1, &ci, array_of_integers,
+                                 &cl, array_of_large_counts,
+                                 &ca, array_of_addresses,
+                                 &cd, array_of_datatypes, NULL );
     if( rc != MPI_SUCCESS ) {
         OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_INTERN, 
                                 MPI_ERR_INTERN, FUNC_NAME );
     }
 
-    for( i = 0; i < max_datatypes; i++ ) {
+    /* Iterate over the actual number of constituent datatypes (cd), not
+     * the caller-provided capacity (max_datatypes): only the first cd
+     * entries of array_of_datatypes[] were filled in above, so iterating
+     * to max_datatypes would dereference uninitialized handles. */
+    for( i = 0; i < cd; i++ ) {
         /* if we have a predefined datatype then we return directly a pointer to
          * the datatype, otherwise we should create a copy and give back the copy.
          */
diff --git a/ompi/mpi/c/type_get_envelope.c b/ompi/mpi/c/type_get_envelope.c
index 2d6861ec5d0..a6b6009a122 100644
--- a/ompi/mpi/c/type_get_envelope.c
+++ b/ompi/mpi/c/type_get_envelope.c
@@ -11,6 +11,7 @@
  *                         All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,7 +29,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_get_envelope = PMPI_Type_get_envelope
 #endif
 #define MPI_Type_get_envelope PMPI_Type_get_envelope
@@ -61,7 +62,16 @@ int MPI_Type_get_envelope(MPI_Datatype type,
       }
    }
 
-   rc = ompi_datatype_get_args( type, 0, num_integers, NULL, num_addresses, NULL,
-                           num_datatypes, NULL, combiner );
+   size_t ci, cl, ca, cd;
+   rc = ompi_datatype_get_args( type, 0, &ci, NULL, &cl, NULL, &ca, NULL,
+                           &cd, NULL, combiner );
+   /* error out if we have large counts or any of the parameters don't fit */
+   if (OMPI_SUCCESS == rc && (ci > INT_MAX || cl > 0 || ca > INT_MAX || cd > INT_MAX)) {
+      return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_TYPE,
+                                      FUNC_NAME );
+   }
+   *num_integers  = (int)ci;
+   *num_addresses = (int)ca;
+   *num_datatypes = (int)cd;
    OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, rc, FUNC_NAME );
 }
diff --git a/ompi/mpi/c/type_get_envelope.c.in b/ompi/mpi/c/type_get_envelope.c.in
deleted file mode 100644
index e5395d796e4..00000000000
--- a/ompi/mpi/c/type_get_envelope.c.in
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2020 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2008 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#include "ompi_config.h"
-
-#include "ompi/mpi/c/bindings.h"
-#include "ompi/runtime/params.h"
-#include "ompi/communicator/communicator.h"
-#include "ompi/errhandler/errhandler.h"
-#include "ompi/datatype/ompi_datatype.h"
-#include "ompi/memchecker.h"
-
-PROTOTYPE ERROR_CLASS Type_get_envelope(DATATYPE type,
-                          INT_OUT num_integers,
-                          INT_OUT num_addresses,
-                          INT_OUT num_datatypes,
-                          INT_OUT combiner)
-{
-   int rc;
-
-   MEMCHECKER(
-      memchecker_datatype(type);
-   );
-
-   if( MPI_PARAM_CHECK ) {
-      OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
-      if (NULL == type || MPI_DATATYPE_NULL == type) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_TYPE,
-                                      FUNC_NAME );
-      } else if (NULL == num_integers || NULL == num_addresses ||
-                 NULL == num_datatypes || NULL == combiner) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG,
-                                      FUNC_NAME );
-      }
-   }
-
-   rc = ompi_datatype_get_args( type, 0, num_integers, NULL, num_addresses, NULL,
-                           num_datatypes, NULL, combiner );
-   OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, rc, FUNC_NAME );
-}
diff --git a/ompi/mpi/c/type_get_envelope_c.c b/ompi/mpi/c/type_get_envelope_c.c
index 24229e327cf..46a79b57bba 100644
--- a/ompi/mpi/c/type_get_envelope_c.c
+++ b/ompi/mpi/c/type_get_envelope_c.c
@@ -11,6 +11,7 @@
  *                         All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,7 +29,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_get_envelope_c = PMPI_Type_get_envelope_c
 #endif
 #define MPI_Type_get_envelope_c PMPI_Type_get_envelope_c
@@ -61,9 +62,15 @@ int MPI_Type_get_envelope_c(MPI_Datatype type,
       }
    }
 
-/* TODO:BIGCOUNT: Need to embiggen ompi_datatype_get_args */
-   rc = ompi_datatype_get_args( type, 0, (int *)num_integers, NULL, (int *)num_addresses, NULL,
-                           (int *)num_datatypes, NULL, combiner );
+   size_t ci, cl, ca, cd;
+   rc = ompi_datatype_get_args( type, 0, &ci, NULL, &cl, NULL, &ca, NULL,
+                           &cd, NULL, combiner );
+   if( rc == MPI_SUCCESS ) {
+      *num_integers = (MPI_Count)ci;
+      *num_addresses = (MPI_Count)ca;
+      *num_large_counts = (MPI_Count)cl;
+      *num_datatypes = (MPI_Count)cd;
+   }
    OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, rc, FUNC_NAME );
 }
 
diff --git a/ompi/mpi/c/type_hindexed.c b/ompi/mpi/c/type_hindexed.c
index 9d81f249df0..ea3bbc668fd 100644
--- a/ompi/mpi/c/type_hindexed.c
+++ b/ompi/mpi/c/type_hindexed.c
@@ -34,7 +34,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_hindexed = PMPI_Type_hindexed
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/type_hvector.c b/ompi/mpi/c/type_hvector.c
index 2c4ca2b2dad..297e0b4ed57 100644
--- a/ompi/mpi/c/type_hvector.c
+++ b/ompi/mpi/c/type_hvector.c
@@ -34,7 +34,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_hvector = PMPI_Type_hvector
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/type_indexed.c.in b/ompi/mpi/c/type_indexed.c.in
index c3ff80c1b1c..8069518f846 100644
--- a/ompi/mpi/c/type_indexed.c.in
+++ b/ompi/mpi/c/type_indexed.c.in
@@ -16,6 +16,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2025-2026 Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -32,11 +33,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
-
 
 PROTOTYPE ERROR_CLASS type_indexed(COUNT count,
                                    COUNT_ARRAY array_of_blocklengths,
@@ -45,8 +41,6 @@ PROTOTYPE ERROR_CLASS type_indexed(COUNT count,
                                    DATATYPE_OUT newtype)
 {
     int rc, i;
-    int *iarray_of_blocklengths;
-    int *iarray_of_displacements;
 
     MEMCHECKER(
         memchecker_datatype(oldtype);
@@ -66,12 +60,6 @@ PROTOTYPE ERROR_CLASS type_indexed(COUNT count,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG,
                                           FUNC_NAME);
         }
-#if OMPI_BIGCOUNT_SRC
-        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
-        if (OMPI_SUCCESS != rc) {
-            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
-        }
-#endif
         for( i = 0; i < count; i++ ) {
             if( array_of_blocklengths[i] < 0 ) {
                 return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG,
@@ -80,44 +68,26 @@ PROTOTYPE ERROR_CLASS type_indexed(COUNT count,
         }
     }
 
-#if OMPI_BIGCOUNT_SRC
-    iarray_of_blocklengths = (int *)malloc(count * sizeof(int));
-    if (NULL == iarray_of_blocklengths) {
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-    iarray_of_displacements = (int *)malloc(count * sizeof(int));
-    if (NULL == iarray_of_displacements) {
-        free(iarray_of_blocklengths);
-        return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_NO_MEM, FUNC_NAME);
-    }
-
-    for (int ii = 0; ii < (int)count; ii++) {
-        iarray_of_blocklengths[ii] = (int)array_of_blocklengths[ii];
-        iarray_of_displacements[ii] = (int)array_of_displacements[ii];
-    }
-#else
-    iarray_of_blocklengths = (int *)array_of_blocklengths;
-    iarray_of_displacements = (int *)array_of_displacements;
-#endif
-    rc = ompi_datatype_create_indexed ( count, iarray_of_blocklengths,
-                                        iarray_of_displacements,
+    rc = ompi_datatype_create_indexed ( count, OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths),
+                                        OMPI_DISP_ARRAY_CREATE(array_of_displacements),
                                         oldtype, newtype );
     if( rc != MPI_SUCCESS ) {
         ompi_datatype_destroy( newtype );
-        OMPI_ERRHANDLER_NOHANDLE_RETURN( rc, 
+        OMPI_ERRHANDLER_NOHANDLE_RETURN( rc,
                                 rc, FUNC_NAME );
     }
 
     {
-        const int* a_i[3] = {(int *)&count, iarray_of_blocklengths, iarray_of_displacements};
+        const ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                            OMPI_COUNT_ARRAY_CREATE(array_of_blocklengths),
+                                            OMPI_DISP_ARRAY_CREATE(array_of_displacements)};
 
-        ompi_datatype_set_args( *newtype, 2 * count + 1, a_i, 0, NULL, 1, &oldtype,
+        ompi_datatype_set_args( *newtype,
+                                (sizeof(count) != 8) ? 2 * count + 1 : 0,
+                                (sizeof(count) == 8) ? 2 * count + 1 : 0,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype,
                                 MPI_COMBINER_INDEXED );
     }
-#if OMPI_BIGCOUNT_SRC
-    free(iarray_of_blocklengths);
-    free(iarray_of_displacements);
-#endif
 
     return MPI_SUCCESS;
 }
diff --git a/ompi/mpi/c/type_lb.c b/ompi/mpi/c/type_lb.c
index 2d5378b6397..f4041d6a0c9 100644
--- a/ompi/mpi/c/type_lb.c
+++ b/ompi/mpi/c/type_lb.c
@@ -35,7 +35,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_lb = PMPI_Type_lb
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/type_size.c.in b/ompi/mpi/c/type_size.c.in
index 6e0897dd7aa..b8f1ef0c0ef 100644
--- a/ompi/mpi/c/type_size.c.in
+++ b/ompi/mpi/c/type_size.c.in
@@ -17,6 +17,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -51,7 +52,11 @@ PROTOTYPE ERROR_CLASS type_size(DATATYPE type, COUNT_OUT size)
 
     opal_datatype_type_size ( &type->super, &type_size);
 
-    *size = (type_size > (size_t) INT_MAX) ? MPI_UNDEFINED : (int) type_size;
+    if (sizeof(*size) == sizeof(int) && type_size > (size_t) INT_MAX) {
+        *size = MPI_UNDEFINED;
+    } else {
+        *size = (MPI_Count) type_size;
+    }
 
     return MPI_SUCCESS;
 }
diff --git a/ompi/mpi/c/type_struct.c b/ompi/mpi/c/type_struct.c
index 0151b99ac49..23849418f1e 100644
--- a/ompi/mpi/c/type_struct.c
+++ b/ompi/mpi/c/type_struct.c
@@ -30,7 +30,7 @@
 #include "ompi/mpi/c/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_struct = PMPI_Type_struct
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/type_ub.c b/ompi/mpi/c/type_ub.c
index 94abcb2c57c..7e7a6c0fde4 100644
--- a/ompi/mpi/c/type_ub.c
+++ b/ompi/mpi/c/type_ub.c
@@ -35,7 +35,7 @@
 #include "ompi/memchecker.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Type_ub = PMPI_Type_ub
 #endif
 /* undef before defining, to prevent possible redefinition when
diff --git a/ompi/mpi/c/type_vector.c.in b/ompi/mpi/c/type_vector.c.in
index 08bad80d75f..af8be19097e 100644
--- a/ompi/mpi/c/type_vector.c.in
+++ b/ompi/mpi/c/type_vector.c.in
@@ -16,6 +16,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -32,10 +33,6 @@
 #include "ompi/datatype/ompi_datatype.h"
 #include "ompi/memchecker.h"
 
-/*
- * TODO:BIGCOUNT this file will need to be updated once
- * the datatype framework supports bigcount 
- */
 
 PROTOTYPE ERROR_CLASS type_vector(COUNT count,
                                   COUNT blocklength,
@@ -62,21 +59,20 @@ PROTOTYPE ERROR_CLASS type_vector(COUNT count,
             OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_ARG, 
                                     MPI_ERR_ARG, FUNC_NAME );
         }
-#if OMPI_BIGCOUNT_SRC
-        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
-        if (OMPI_SUCCESS != rc) {
-            OMPI_ERRHANDLER_NOHANDLE_RETURN(rc, rc, FUNC_NAME);
-        }
-#endif
     }
 
     rc = ompi_datatype_create_vector ( count, blocklength, stride, oldtype, newtype );
     OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME );
 
     {
-        const int* a_i[3] = {(int *)&count, (int *)&blocklength, (int *)&stride};
+        const ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                           OMPI_COUNT_ARRAY_CREATE(&blocklength),
+                                           OMPI_COUNT_ARRAY_CREATE(&stride)};
 
-        ompi_datatype_set_args( *newtype, 3, a_i, 0, NULL, 1, &oldtype, MPI_COMBINER_VECTOR );
+        ompi_datatype_set_args( *newtype,
+                                (sizeof(count) != 8) ? 3 : 0,
+                                (sizeof(count) == 8) ? 3 : 0,
+                                a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype, MPI_COMBINER_VECTOR );
     }
 
     return MPI_SUCCESS;
diff --git a/ompi/mpi/c/unpack.c.in b/ompi/mpi/c/unpack.c.in
index 94055ceef94..3aa520c6524 100644
--- a/ompi/mpi/c/unpack.c.in
+++ b/ompi/mpi/c/unpack.c.in
@@ -97,7 +97,7 @@ PROTOTYPE ERROR_CLASS unpack(BUFFER inbuf,
 
         /* Check for truncation */
         opal_convertor_get_packed_size( &local_convertor, &size );
-        if( (*position + size) > (unsigned int)insize ) {
+        if( (*position + size) > (size_t)insize ) {
             OBJ_DESTRUCT( &local_convertor );
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_TRUNCATE, FUNC_NAME);
         }
diff --git a/ompi/mpi/c/win_f2c.c b/ompi/mpi/c/win_f2c.c
index 82bf2b9cc71..ff77bcf9d96 100644
--- a/ompi/mpi/c/win_f2c.c
+++ b/ompi/mpi/c/win_f2c.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/fint_2_int.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Win_f2c = PMPI_Win_f2c
 #endif
 #define MPI_Win_f2c PMPI_Win_f2c
diff --git a/ompi/mpi/c/win_get_notify_value.c.in b/ompi/mpi/c/win_get_notify_value.c.in
new file mode 100644
index 00000000000..4dfcafbab05
--- /dev/null
+++ b/ompi/mpi/c/win_get_notify_value.c.in
@@ -0,0 +1,45 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+
+PROTOTYPE ERROR_CLASS win_get_notify_value(WIN win, INT notification_idx, ELEMENT_COUNT value)
+{
+    int rc;
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (notification_idx < 0) {
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else if (NULL == value) {
+            rc = MPI_ERR_ARG;
+        }
+
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_win_get_notify_value) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    rc = win->w_osc_module->osc_win_get_notify_value(win, notification_idx, value);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/win_get_num_notify.c.in b/ompi/mpi/c/win_get_num_notify.c.in
new file mode 100644
index 00000000000..790a740c65a
--- /dev/null
+++ b/ompi/mpi/c/win_get_num_notify.c.in
@@ -0,0 +1,48 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+
+PROTOTYPE ERROR_CLASS win_get_num_notify(WIN win, INT target_rank, INT_OUT num_notifications)
+{
+    int rc;
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (ompi_win_peer_invalid(win, target_rank)) {
+            /* target_rank is specified as a nonnegative integer in the group of
+             * the window; unlike the notified communication operations,
+             * MPI_PROC_NULL is not permitted here. */
+            rc = MPI_ERR_RANK;
+        } else if (NULL == num_notifications) {
+            rc = MPI_ERR_ARG;
+        }
+
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_win_get_num_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    rc = win->w_osc_module->osc_win_get_num_notify(win, target_rank, num_notifications);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/win_reset_notify_value.c.in b/ompi/mpi/c/win_reset_notify_value.c.in
new file mode 100644
index 00000000000..09a132555f5
--- /dev/null
+++ b/ompi/mpi/c/win_reset_notify_value.c.in
@@ -0,0 +1,45 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/mca/osc/osc.h"
+
+PROTOTYPE ERROR_CLASS win_reset_notify_value(WIN win, INT notification_idx, ELEMENT_COUNT value)
+{
+    int rc;
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (notification_idx < 0) {
+            rc = MPI_ERR_RMA_NOTIFICATION;
+        } else if (NULL == value) {
+            rc = MPI_ERR_ARG;
+        }
+
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_win_reset_notify_value) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    rc = win->w_osc_module->osc_win_reset_notify_value(win, notification_idx, value);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/win_set_num_notify.c.in b/ompi/mpi/c/win_set_num_notify.c.in
new file mode 100644
index 00000000000..f85bf1c8fd8
--- /dev/null
+++ b/ompi/mpi/c/win_set_num_notify.c.in
@@ -0,0 +1,55 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#include "ompi_config.h"
+
+#include "ompi/mpi/c/bindings.h"
+#include "ompi/runtime/params.h"
+#include "ompi/errhandler/errhandler.h"
+#include "ompi/win/win.h"
+#include "ompi/info/info.h"
+#include "ompi/mca/osc/osc.h"
+
+PROTOTYPE ERROR_CLASS win_set_num_notify(WIN win, INFO info, INT num_notifications)
+{
+    int rc;
+
+    if (MPI_PARAM_CHECK) {
+        rc = OMPI_SUCCESS;
+
+        OMPI_ERR_INIT_FINALIZE(FUNC_NAME);
+
+        if (ompi_win_invalid(win)) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_WIN, FUNC_NAME);
+        } else if (NULL != info && MPI_INFO_NULL != info && ompi_info_is_freed(info)) {
+            rc = MPI_ERR_INFO;
+        }
+
+        /* num_notifications is deliberately *not* range-checked here.
+           MPI_WIN_SET_NUM_NOTIFY is a synchronizing collective whose count
+           argument is local -- MPI-5.1 12.6.1 allows it to differ between MPI
+           processes -- so a rank that rejected its own value here would return
+           while every other rank stayed blocked in the osc module's internal
+           collective, turning an erroneous argument into a hang.  The module
+           carries each rank's validity through that collective instead, so all
+           ranks agree to fail together. */
+
+        OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME);
+    }
+
+    if (NULL == win->w_osc_module->osc_win_set_num_notify) {
+        return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_UNSUPPORTED_OPERATION, FUNC_NAME);
+    }
+
+    rc = win->w_osc_module->osc_win_set_num_notify(win,
+             (NULL != info && MPI_INFO_NULL != info) ? &(info->super) : NULL,
+             num_notifications);
+    OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME);
+}
diff --git a/ompi/mpi/c/wtick.c b/ompi/mpi/c/wtick.c
index 3136a7e1b08..5deb7c98b22 100644
--- a/ompi/mpi/c/wtick.c
+++ b/ompi/mpi/c/wtick.c
@@ -37,7 +37,7 @@
 #include "opal/util/clock_gettime.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_Wtick = PMPI_Wtick
 #endif
 #define MPI_Wtick PMPI_Wtick
diff --git a/ompi/mpi/fortran/base/Makefile.am b/ompi/mpi/fortran/base/Makefile.am
index 100fba8991c..a9f5ca147f7 100644
--- a/ompi/mpi/fortran/base/Makefile.am
+++ b/ompi/mpi/fortran/base/Makefile.am
@@ -13,6 +13,8 @@
 # Copyright (c) 2015-2017 Research Organization for Information Science
 #                         and Technology (RIST). All rights reserved.
 # Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2026      Triad National Security, LLC. All rights
+#                         reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -51,5 +53,7 @@ libmpi_fortran_base_la_SOURCES = \
         conversion_fn_null_f.c \
         f90_accessors.c \
         strings.c \
-        test_constants_f.c
+        test_constants_f.c \
+        fortran_base_topo_neighbors.h \
+        topo_neighbors.c
 endif
diff --git a/ompi/mpi/fortran/base/attr_fn_f.c b/ompi/mpi/fortran/base/attr_fn_f.c
index efdb8238aca..add895fa843 100644
--- a/ompi/mpi/fortran/base/attr_fn_f.c
+++ b/ompi/mpi/fortran/base/attr_fn_f.c
@@ -22,7 +22,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 #include "ompi/mpi/fortran/base/fint_2_int.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_NULL_COPY_FN   = ompi_type_null_copy_fn_f
 #pragma weak mpi_type_null_copy_fn   = ompi_type_null_copy_fn_f
 #pragma weak mpi_type_null_copy_fn_  = ompi_type_null_copy_fn_f
diff --git a/ompi/mpi/fortran/base/constants.h b/ompi/mpi/fortran/base/constants.h
index b2bc142df08..65f8797ab0b 100644
--- a/ompi/mpi/fortran/base/constants.h
+++ b/ompi/mpi/fortran/base/constants.h
@@ -56,7 +56,7 @@
  *
  * Since we made the fundamental decision to support all 4 common
  * fortran compiler symbol conventions within the same library for
- * those compilers who support weak symbols, we need to have 4 symbols
+ * those compilers who support weak aliases, we need to have 4 symbols
  * for each of the fortran address constants.  As described above, we
  * have to have known *pointer* values for the fortran addresses
  * (e.g., MPI_STATUS_IGNORE).  So when the fortran wrapper for
@@ -83,7 +83,7 @@
  *
  * I'm putting these 4 comparisons in macros (on systems where we
  * don't support the 4 symbols -- e.g., OSX, where we don't have weak
- * symbols -- it'll only be one comparison), so if anyone things of
+ * aliases -- it'll only be one comparison), so if anyone things of
  * something better than this, you should only need to modify this
  * file.
  */
diff --git a/ompi/mpi/fortran/base/conversion_fn_null_f.c b/ompi/mpi/fortran/base/conversion_fn_null_f.c
index 9e83f03e699..6e78d7ad181 100644
--- a/ompi/mpi/fortran/base/conversion_fn_null_f.c
+++ b/ompi/mpi/fortran/base/conversion_fn_null_f.c
@@ -40,14 +40,14 @@
 #include "ompi/mpi/fortran/base/fint_2_int.h"
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CONVERSION_FN_NULL   = mpi_conversion_fn_null_f
 #pragma weak mpi_conversion_fn_null   = mpi_conversion_fn_null_f
 #pragma weak mpi_conversion_fn_null_  = mpi_conversion_fn_null_f
 #pragma weak mpi_conversion_fn_null__ = mpi_conversion_fn_null_f
 #endif
 
-#if ! OPAL_HAVE_WEAK_SYMBOLS && ! OMPI_PROFILE_LAYER
+#if ! OPAL_HAVE_WEAK_ALIASES && ! OMPI_PROFILE_LAYER
 OMPI_GENERATE_F77_BINDINGS(MPI_CONVERSION_FN_NULL,
                            mpi_conversion_fn_null,
                            mpi_conversion_fn_null_,
diff --git a/ompi/mpi/fortran/base/f90_accessors.c b/ompi/mpi/fortran/base/f90_accessors.c
index e163afb7f6d..d6e385e7fdc 100644
--- a/ompi/mpi/fortran/base/f90_accessors.c
+++ b/ompi/mpi/fortran/base/f90_accessors.c
@@ -33,7 +33,7 @@
    names (MPI_WTICK_F90 and MPI_WTIME_F90 vs. MPI_WTICK and MPI_WTIME)
    so that the F90 bindings can call these functions directly.
 
-   Rather than try to be clever with weak symbols, especially since
+   Rather than try to be clever with weak aliases, especially since
    the function implementations are 1 line long, it just seemed
    simpler to provide 4 copies of each [1 line] function. */
 
diff --git a/ompi/mpi/fortran/base/fortran_base_topo_neighbors.h b/ompi/mpi/fortran/base/fortran_base_topo_neighbors.h
new file mode 100644
index 00000000000..9d170b96193
--- /dev/null
+++ b/ompi/mpi/fortran/base/fortran_base_topo_neighbors.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2010-2018 Cisco Systems, Inc.  All rights reserved
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#ifndef OMPI_FORTRAN_BASE_TOPO_NEIGHBORS_H
+#define OMPI_FORTRAN_BASE_TOPO_NEIGHBORS_H
+
+#include "mpi.h"
+#include "ompi_config.h"
+
+BEGIN_C_DECLS
+/**
+ * Return number of neighbors given a supplied communicator
+ *
+ * @param[in]  c_comm      MPI communicator (must have an associated topology)
+ * @param[out] indegree    number of neighbors directed in 
+ * @param[out] outdegree   number of neighbors directed out
+ *
+ * See 8.6 "Neighborhood Collective Communication on Virtual Topologies" of 
+ * the MPI 5 standard for additional info about number of neighbors for 
+ * the three different topology types supported by MPI as of that version
+ * of the standard.
+ *
+ * Note only top-level 'c' MPI interfaces are used here as the intent
+ * is for this function to work in the case that the OMPI fortran interface
+ * base is moved to an external package at some point.
+ */
+OMPI_DECLSPEC int ompi_fortran_neighbor_count(MPI_Comm comm, int *indegree, int *outdegree);
+
+END_C_DECLS
+
+#endif /* OMPI_FORTRAN_BASE_TOPO_NEIGHBORS_H */
diff --git a/ompi/mpi/fortran/base/test_constants_f.c b/ompi/mpi/fortran/base/test_constants_f.c
index 59a5630fabb..fa5e9939370 100644
--- a/ompi/mpi/fortran/base/test_constants_f.c
+++ b/ompi/mpi/fortran/base/test_constants_f.c
@@ -35,14 +35,14 @@ OMPI_DECLSPEC void ompi_test_fortran_constants_f(char *bottom, char *in_place,
 
 PN2(void, OMPI_Test_fortran_constants, ompi_test_fortran_constants, OMPI_TEST_FORTRAN_CONSTANTS, (char *bottom, char *in_place, char *argv, char *argvs, char *status, char *statuses, MPI_Fint *flag));
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak OMPI_TEST_FORTRAN_CONSTANTS   = ompi_test_fortran_constants_f
 #pragma weak ompi_test_fortran_constants   = ompi_test_fortran_constants_f
 #pragma weak ompi_test_fortran_constants_  = ompi_test_fortran_constants_f
 #pragma weak ompi_test_fortran_constants__ = ompi_test_fortran_constants_f
 #endif
 
-#if ! OPAL_HAVE_WEAK_SYMBOLS
+#if ! OPAL_HAVE_WEAK_ALIASES
 OMPI_GENERATE_F77_BINDINGS (OMPI_TEST_FORTRAN_CONSTANTS,
                             ompi_test_fortran_constants,
                             ompi_test_fortran_constants_,
diff --git a/ompi/mpi/fortran/base/topo_neighbors.c b/ompi/mpi/fortran/base/topo_neighbors.c
new file mode 100644
index 00000000000..a5ec35ef836
--- /dev/null
+++ b/ompi/mpi/fortran/base/topo_neighbors.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "mpi.h"
+#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"
+
+int ompi_fortran_neighbor_count(MPI_Comm comm, int *indegree, int *outdegree)
+{
+    int ret;
+    int topo_type, ndims, nneighbors, weighted, my_rank;
+
+    if ((NULL == indegree) || (NULL == outdegree)) {
+        ret = MPI_ERR_ARG;
+        goto fn_exit;
+    }
+        
+    ret = PMPI_Topo_test(comm, &topo_type);
+    if (MPI_SUCCESS != ret) {
+        goto fn_exit;
+    }
+
+    switch (topo_type) {
+        case MPI_CART:
+            ret = PMPI_Cartdim_get(comm, &ndims);
+            if (MPI_SUCCESS != ret) {
+                goto fn_exit;
+            }
+            *outdegree = *indegree = 2 * ndims; 
+            break;
+        case MPI_GRAPH:
+            ret = PMPI_Comm_rank(comm, &my_rank);
+            if (MPI_SUCCESS != ret) {
+                goto fn_exit;
+            }
+            ret = PMPI_Graph_neighbors_count(comm, my_rank, &nneighbors);
+            if (MPI_SUCCESS != ret) {
+                goto fn_exit;
+            }
+            *outdegree = *indegree = nneighbors;
+            break;
+        case MPI_DIST_GRAPH:
+            ret = PMPI_Dist_graph_neighbors_count(comm, indegree, outdegree, &weighted);
+            if (MPI_SUCCESS != ret) {
+                goto fn_exit;
+            }
+            break;
+        case MPI_UNDEFINED:
+        default:
+            break;
+    }
+
+fn_exit:
+    return ret;
+}
diff --git a/ompi/mpi/fortran/mpif-h/Makefile.am b/ompi/mpi/fortran/mpif-h/Makefile.am
index 6280e37cb8a..0b306d9ab2a 100644
--- a/ompi/mpi/fortran/mpif-h/Makefile.am
+++ b/ompi/mpi/fortran/mpif-h/Makefile.am
@@ -48,7 +48,7 @@ AM_CPPFLAGS = -DOMPI_BUILD_MPI_PROFILING=0 -DOMPI_COMPILING_FORTRAN_WRAPPERS=1
 # to be built are:
 #
 # 1. When profiling is disabled
-# 2. When profiling is enabled but weak symbol support is absent
+# 2. When profiling is enabled but weak alias support is absent
 #
 
 lib_LTLIBRARIES =
@@ -453,9 +453,15 @@ lib@OMPI_LIBMPI_NAME@_mpifh_la_SOURCES += \
         start_f.c \
         status_f082f_f.c \
         status_f2f08_f.c \
+        status_get_error_f.c \
+        status_get_source_f.c \
+        status_get_tag_f.c \
         status_set_cancelled_f.c \
         status_set_elements_f.c \
         status_set_elements_x_f.c \
+        status_set_error_f.c \
+        status_set_source_f.c \
+        status_set_tag_f.c \
         testall_f.c \
         testany_f.c \
         test_cancelled_f.c \
diff --git a/ompi/mpi/fortran/mpif-h/abort_f.c b/ompi/mpi/fortran/mpif-h/abort_f.c
index 917ad13f13d..5762e469906 100644
--- a/ompi/mpi/fortran/mpif-h/abort_f.c
+++ b/ompi/mpi/fortran/mpif-h/abort_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ABORT = ompi_abort_f
 #pragma weak pmpi_abort = ompi_abort_f
 #pragma weak pmpi_abort_ = ompi_abort_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS(PMPI_ABORT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ABORT = ompi_abort_f
 #pragma weak mpi_abort = ompi_abort_f
 #pragma weak mpi_abort_ = ompi_abort_f
diff --git a/ompi/mpi/fortran/mpif-h/accumulate_f.c b/ompi/mpi/fortran/mpif-h/accumulate_f.c
index c9b6460a683..f0c9425dfe6 100644
--- a/ompi/mpi/fortran/mpif-h/accumulate_f.c
+++ b/ompi/mpi/fortran/mpif-h/accumulate_f.c
@@ -26,7 +26,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ACCUMULATE = ompi_accumulate_f
 #pragma weak pmpi_accumulate = ompi_accumulate_f
 #pragma weak pmpi_accumulate_ = ompi_accumulate_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ACCUMULATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ACCUMULATE = ompi_accumulate_f
 #pragma weak mpi_accumulate = ompi_accumulate_f
 #pragma weak mpi_accumulate_ = ompi_accumulate_f
diff --git a/ompi/mpi/fortran/mpif-h/add_error_class_f.c b/ompi/mpi/fortran/mpif-h/add_error_class_f.c
index 6ce7e0f12d9..27f97e1f835 100644
--- a/ompi/mpi/fortran/mpif-h/add_error_class_f.c
+++ b/ompi/mpi/fortran/mpif-h/add_error_class_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ADD_ERROR_CLASS = ompi_add_error_class_f
 #pragma weak pmpi_add_error_class = ompi_add_error_class_f
 #pragma weak pmpi_add_error_class_ = ompi_add_error_class_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ADD_ERROR_CLASS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ADD_ERROR_CLASS = ompi_add_error_class_f
 #pragma weak mpi_add_error_class = ompi_add_error_class_f
 #pragma weak mpi_add_error_class_ = ompi_add_error_class_f
diff --git a/ompi/mpi/fortran/mpif-h/add_error_code_f.c b/ompi/mpi/fortran/mpif-h/add_error_code_f.c
index 818b7c1ced7..5df7577e161 100644
--- a/ompi/mpi/fortran/mpif-h/add_error_code_f.c
+++ b/ompi/mpi/fortran/mpif-h/add_error_code_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ADD_ERROR_CODE = ompi_add_error_code_f
 #pragma weak pmpi_add_error_code = ompi_add_error_code_f
 #pragma weak pmpi_add_error_code_ = ompi_add_error_code_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ADD_ERROR_CODE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ADD_ERROR_CODE = ompi_add_error_code_f
 #pragma weak mpi_add_error_code = ompi_add_error_code_f
 #pragma weak mpi_add_error_code_ = ompi_add_error_code_f
diff --git a/ompi/mpi/fortran/mpif-h/add_error_string_f.c b/ompi/mpi/fortran/mpif-h/add_error_string_f.c
index 6837234daef..d58d44f309e 100644
--- a/ompi/mpi/fortran/mpif-h/add_error_string_f.c
+++ b/ompi/mpi/fortran/mpif-h/add_error_string_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ADD_ERROR_STRING = ompi_add_error_string_f
 #pragma weak pmpi_add_error_string = ompi_add_error_string_f
 #pragma weak pmpi_add_error_string_ = ompi_add_error_string_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ADD_ERROR_STRING,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ADD_ERROR_STRING = ompi_add_error_string_f
 #pragma weak mpi_add_error_string = ompi_add_error_string_f
 #pragma weak mpi_add_error_string_ = ompi_add_error_string_f
diff --git a/ompi/mpi/fortran/mpif-h/address_f.c b/ompi/mpi/fortran/mpif-h/address_f.c
index 85d1369ae2d..d6d32238f30 100644
--- a/ompi/mpi/fortran/mpif-h/address_f.c
+++ b/ompi/mpi/fortran/mpif-h/address_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ADDRESS = ompi_address_f
 #pragma weak pmpi_address = ompi_address_f
 #pragma weak pmpi_address_ = ompi_address_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ADDRESS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ADDRESS = ompi_address_f
 #pragma weak mpi_address = ompi_address_f
 #pragma weak mpi_address_ = ompi_address_f
diff --git a/ompi/mpi/fortran/mpif-h/aint_add_f.c b/ompi/mpi/fortran/mpif-h/aint_add_f.c
index 3f5af406070..bb40ee8e153 100644
--- a/ompi/mpi/fortran/mpif-h/aint_add_f.c
+++ b/ompi/mpi/fortran/mpif-h/aint_add_f.c
@@ -32,7 +32,7 @@
  * manually.
  */
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_AINT_ADD = ompi_aint_add_f
 #pragma weak pmpi_aint_add = ompi_aint_add_f
 #pragma weak pmpi_aint_add_ = ompi_aint_add_f
@@ -48,7 +48,7 @@ MPI_Aint pmpi_aint_add__(MPI_Aint *base, MPI_Aint *diff) { return pompi_aint_add
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_AINT_ADD = ompi_aint_add_f
 #pragma weak mpi_aint_add = ompi_aint_add_f
 #pragma weak mpi_aint_add_ = ompi_aint_add_f
diff --git a/ompi/mpi/fortran/mpif-h/aint_diff_f.c b/ompi/mpi/fortran/mpif-h/aint_diff_f.c
index c9c8ca43a07..9cb73358ac4 100644
--- a/ompi/mpi/fortran/mpif-h/aint_diff_f.c
+++ b/ompi/mpi/fortran/mpif-h/aint_diff_f.c
@@ -32,7 +32,7 @@
  * manually.
  */
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_AINT_DIFF = ompi_aint_diff_f
 #pragma weak pmpi_aint_diff = ompi_aint_diff_f
 #pragma weak pmpi_aint_diff_ = ompi_aint_diff_f
@@ -48,7 +48,7 @@ MPI_Aint pmpi_aint_diff__(MPI_Aint *addr1, MPI_Aint *addr2) { return pompi_aint_
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_AINT_DIFF = ompi_aint_diff_f
 #pragma weak mpi_aint_diff = ompi_aint_diff_f
 #pragma weak mpi_aint_diff_ = ompi_aint_diff_f
diff --git a/ompi/mpi/fortran/mpif-h/allgather_f.c b/ompi/mpi/fortran/mpif-h/allgather_f.c
index 1e9c56caaf9..138b03529b2 100644
--- a/ompi/mpi/fortran/mpif-h/allgather_f.c
+++ b/ompi/mpi/fortran/mpif-h/allgather_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLGATHER = ompi_allgather_f
 #pragma weak pmpi_allgather = ompi_allgather_f
 #pragma weak pmpi_allgather_ = ompi_allgather_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLGATHER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLGATHER = ompi_allgather_f
 #pragma weak mpi_allgather = ompi_allgather_f
 #pragma weak mpi_allgather_ = ompi_allgather_f
diff --git a/ompi/mpi/fortran/mpif-h/allgather_init_f.c b/ompi/mpi/fortran/mpif-h/allgather_init_f.c
index 784bad0628d..5009b423e09 100644
--- a/ompi/mpi/fortran/mpif-h/allgather_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/allgather_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLGATHER_INIT = ompi_allgather_init_f
 #pragma weak pmpi_allgather_init = ompi_allgather_init_f
 #pragma weak pmpi_allgather_init_ = ompi_allgather_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLGATHER_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLGATHER_INIT = ompi_allgather_init_f
 #pragma weak mpi_allgather_init = ompi_allgather_init_f
 #pragma weak mpi_allgather_init_ = ompi_allgather_init_f
diff --git a/ompi/mpi/fortran/mpif-h/allgatherv_f.c b/ompi/mpi/fortran/mpif-h/allgatherv_f.c
index 7917136c0f1..84deb40d88a 100644
--- a/ompi/mpi/fortran/mpif-h/allgatherv_f.c
+++ b/ompi/mpi/fortran/mpif-h/allgatherv_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLGATHERV = ompi_allgatherv_f
 #pragma weak pmpi_allgatherv = ompi_allgatherv_f
 #pragma weak pmpi_allgatherv_ = ompi_allgatherv_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLGATHERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLGATHERV = ompi_allgatherv_f
 #pragma weak mpi_allgatherv = ompi_allgatherv_f
 #pragma weak mpi_allgatherv_ = ompi_allgatherv_f
diff --git a/ompi/mpi/fortran/mpif-h/allgatherv_init_f.c b/ompi/mpi/fortran/mpif-h/allgatherv_init_f.c
index 0d98627c440..632ca786d4e 100644
--- a/ompi/mpi/fortran/mpif-h/allgatherv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/allgatherv_init_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLGATHERV_INIT = ompi_allgatherv_init_f
 #pragma weak pmpi_allgatherv_init = ompi_allgatherv_init_f
 #pragma weak pmpi_allgatherv_init_ = ompi_allgatherv_init_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLGATHERV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLGATHERV_INIT = ompi_allgatherv_init_f
 #pragma weak mpi_allgatherv_init = ompi_allgatherv_init_f
 #pragma weak mpi_allgatherv_init_ = ompi_allgatherv_init_f
@@ -77,7 +79,7 @@ void ompi_allgatherv_init_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendty
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
     MPI_Info c_info;
-    int size, idx = 0, ierr_c;
+    int size, ierr_c;
     OMPI_ARRAY_NAME_DECL(recvcounts);
     OMPI_ARRAY_NAME_DECL(displs);
 
@@ -105,12 +107,11 @@ void ompi_allgatherv_init_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendty
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(ierr_c);
     if (MPI_SUCCESS == ierr_c) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (recvcounts != OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(displs);
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request,OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request,OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
      } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(displs);
diff --git a/ompi/mpi/fortran/mpif-h/alloc_mem_f.c b/ompi/mpi/fortran/mpif-h/alloc_mem_f.c
index 75704508137..19148123ae2 100644
--- a/ompi/mpi/fortran/mpif-h/alloc_mem_f.c
+++ b/ompi/mpi/fortran/mpif-h/alloc_mem_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLOC_MEM = ompi_alloc_mem_f
 #pragma weak pmpi_alloc_mem = ompi_alloc_mem_f
 #pragma weak pmpi_alloc_mem_ = ompi_alloc_mem_f
@@ -59,7 +59,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLOC_MEM_CPTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLOC_MEM = ompi_alloc_mem_f
 #pragma weak mpi_alloc_mem = ompi_alloc_mem_f
 #pragma weak mpi_alloc_mem_ = ompi_alloc_mem_f
diff --git a/ompi/mpi/fortran/mpif-h/allreduce_f.c b/ompi/mpi/fortran/mpif-h/allreduce_f.c
index b097e74c0b0..b92d49cf515 100644
--- a/ompi/mpi/fortran/mpif-h/allreduce_f.c
+++ b/ompi/mpi/fortran/mpif-h/allreduce_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLREDUCE = ompi_allreduce_f
 #pragma weak pmpi_allreduce = ompi_allreduce_f
 #pragma weak pmpi_allreduce_ = ompi_allreduce_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLREDUCE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLREDUCE = ompi_allreduce_f
 #pragma weak mpi_allreduce = ompi_allreduce_f
 #pragma weak mpi_allreduce_ = ompi_allreduce_f
diff --git a/ompi/mpi/fortran/mpif-h/allreduce_init_f.c b/ompi/mpi/fortran/mpif-h/allreduce_init_f.c
index 48c250d8078..42042f08e0e 100644
--- a/ompi/mpi/fortran/mpif-h/allreduce_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/allreduce_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLREDUCE_INIT = ompi_allreduce_init_f
 #pragma weak pmpi_allreduce_init = ompi_allreduce_init_f
 #pragma weak pmpi_allreduce_init_ = ompi_allreduce_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLREDUCE_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLREDUCE_INIT = ompi_allreduce_init_f
 #pragma weak mpi_allreduce_init = ompi_allreduce_init_f
 #pragma weak mpi_allreduce_init_ = ompi_allreduce_init_f
diff --git a/ompi/mpi/fortran/mpif-h/alltoall_f.c b/ompi/mpi/fortran/mpif-h/alltoall_f.c
index 2934fe97e49..89439769421 100644
--- a/ompi/mpi/fortran/mpif-h/alltoall_f.c
+++ b/ompi/mpi/fortran/mpif-h/alltoall_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLTOALL = ompi_alltoall_f
 #pragma weak pmpi_alltoall = ompi_alltoall_f
 #pragma weak pmpi_alltoall_ = ompi_alltoall_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLTOALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLTOALL = ompi_alltoall_f
 #pragma weak mpi_alltoall = ompi_alltoall_f
 #pragma weak mpi_alltoall_ = ompi_alltoall_f
diff --git a/ompi/mpi/fortran/mpif-h/alltoall_init_f.c b/ompi/mpi/fortran/mpif-h/alltoall_init_f.c
index baa268533e2..b57631f1409 100644
--- a/ompi/mpi/fortran/mpif-h/alltoall_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/alltoall_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLTOALL_INIT = ompi_alltoall_init_f
 #pragma weak pmpi_alltoall_init = ompi_alltoall_init_f
 #pragma weak pmpi_alltoall_init_ = ompi_alltoall_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLTOALL_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLTOALL_INIT = ompi_alltoall_init_f
 #pragma weak mpi_alltoall_init = ompi_alltoall_init_f
 #pragma weak mpi_alltoall_init_ = ompi_alltoall_init_f
diff --git a/ompi/mpi/fortran/mpif-h/alltoallv_f.c b/ompi/mpi/fortran/mpif-h/alltoallv_f.c
index 3b7b588c5e7..705e88def9c 100644
--- a/ompi/mpi/fortran/mpif-h/alltoallv_f.c
+++ b/ompi/mpi/fortran/mpif-h/alltoallv_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLTOALLV = ompi_alltoallv_f
 #pragma weak pmpi_alltoallv = ompi_alltoallv_f
 #pragma weak pmpi_alltoallv_ = ompi_alltoallv_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLTOALLV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLTOALLV = ompi_alltoallv_f
 #pragma weak mpi_alltoallv = ompi_alltoallv_f
 #pragma weak mpi_alltoallv_ = ompi_alltoallv_f
diff --git a/ompi/mpi/fortran/mpif-h/alltoallv_init_f.c b/ompi/mpi/fortran/mpif-h/alltoallv_init_f.c
index 1a10b0eadad..b64f245596a 100644
--- a/ompi/mpi/fortran/mpif-h/alltoallv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/alltoallv_init_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLTOALLV_INIT = ompi_alltoallv_init_f
 #pragma weak pmpi_alltoallv_init = ompi_alltoallv_init_f
 #pragma weak pmpi_alltoallv_init_ = ompi_alltoallv_init_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLTOALLV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLTOALLV_INIT = ompi_alltoallv_init_f
 #pragma weak mpi_alltoallv_init = ompi_alltoallv_init_f
 #pragma weak mpi_alltoallv_init_ = ompi_alltoallv_init_f
@@ -77,7 +79,7 @@ void ompi_alltoallv_init_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *sdispl
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Info c_info;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(sdispls);
     OMPI_ARRAY_NAME_DECL(recvcounts);
@@ -109,14 +111,13 @@ void ompi_alltoallv_init_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *sdispl
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sdispls);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(rdispls);
+        if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sdispls));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(rdispls));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
     } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sendcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sdispls);
diff --git a/ompi/mpi/fortran/mpif-h/alltoallw_f.c b/ompi/mpi/fortran/mpif-h/alltoallw_f.c
index 55b782a7928..3ff40e3c4b0 100644
--- a/ompi/mpi/fortran/mpif-h/alltoallw_f.c
+++ b/ompi/mpi/fortran/mpif-h/alltoallw_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLTOALLW = ompi_alltoallw_f
 #pragma weak pmpi_alltoallw = ompi_alltoallw_f
 #pragma weak pmpi_alltoallw_ = ompi_alltoallw_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLTOALLW,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLTOALLW = ompi_alltoallw_f
 #pragma weak mpi_alltoallw = ompi_alltoallw_f
 #pragma weak mpi_alltoallw_ = ompi_alltoallw_f
diff --git a/ompi/mpi/fortran/mpif-h/alltoallw_init_f.c b/ompi/mpi/fortran/mpif-h/alltoallw_init_f.c
index 24b0489ba43..98491359f9f 100644
--- a/ompi/mpi/fortran/mpif-h/alltoallw_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/alltoallw_init_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ALLTOALLW_INIT = ompi_alltoallw_init_f
 #pragma weak pmpi_alltoallw_init = ompi_alltoallw_init_f
 #pragma weak pmpi_alltoallw_init_ = ompi_alltoallw_init_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ALLTOALLW_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ALLTOALLW_INIT = ompi_alltoallw_init_f
 #pragma weak mpi_alltoallw_init = ompi_alltoallw_init_f
 #pragma weak mpi_alltoallw_init_ = ompi_alltoallw_init_f
@@ -78,7 +80,7 @@ void ompi_alltoallw_init_f(char *sendbuf, MPI_Fint *sendcounts,
     MPI_Datatype *c_sendtypes = NULL, *c_recvtypes;
     MPI_Info c_info;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(sdispls);
     OMPI_ARRAY_NAME_DECL(recvcounts);
@@ -119,20 +121,19 @@ void ompi_alltoallw_init_f(char *sendbuf, MPI_Fint *sendcounts,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        nb_request->data.release_arrays[idx++] = c_recvtypes;
-        if (recvcounts != OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(rdispls);
+        ompi_coll_base_append_array_to_release(c_request, c_recvtypes);
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(rdispls));
         }
         if (NULL != c_sendtypes) {
-            nb_request->data.release_arrays[idx++] = c_sendtypes;
-            if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-                nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-                nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sdispls);
+            ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
+            if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+                ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+                ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sdispls));
             }
         }
-        nb_request->data.release_arrays[idx]   = NULL;
+        ompi_coll_base_add_release_arrays_cb(c_request);
     } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sendcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sdispls);
diff --git a/ompi/mpi/fortran/mpif-h/attr_delete_f.c b/ompi/mpi/fortran/mpif-h/attr_delete_f.c
index fc3a1398b1d..fe092bb1e0f 100644
--- a/ompi/mpi/fortran/mpif-h/attr_delete_f.c
+++ b/ompi/mpi/fortran/mpif-h/attr_delete_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ATTR_DELETE = ompi_attr_delete_f
 #pragma weak pmpi_attr_delete = ompi_attr_delete_f
 #pragma weak pmpi_attr_delete_ = ompi_attr_delete_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ATTR_DELETE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ATTR_DELETE = ompi_attr_delete_f
 #pragma weak mpi_attr_delete = ompi_attr_delete_f
 #pragma weak mpi_attr_delete_ = ompi_attr_delete_f
diff --git a/ompi/mpi/fortran/mpif-h/attr_get_f.c b/ompi/mpi/fortran/mpif-h/attr_get_f.c
index bc4c910ca94..7c4b9652077 100644
--- a/ompi/mpi/fortran/mpif-h/attr_get_f.c
+++ b/ompi/mpi/fortran/mpif-h/attr_get_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ATTR_GET = ompi_attr_get_f
 #pragma weak pmpi_attr_get = ompi_attr_get_f
 #pragma weak pmpi_attr_get_ = ompi_attr_get_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ATTR_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ATTR_GET = ompi_attr_get_f
 #pragma weak mpi_attr_get = ompi_attr_get_f
 #pragma weak mpi_attr_get_ = ompi_attr_get_f
diff --git a/ompi/mpi/fortran/mpif-h/attr_put_f.c b/ompi/mpi/fortran/mpif-h/attr_put_f.c
index db45fc7e318..3aa229c21e6 100644
--- a/ompi/mpi/fortran/mpif-h/attr_put_f.c
+++ b/ompi/mpi/fortran/mpif-h/attr_put_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ATTR_PUT = ompi_attr_put_f
 #pragma weak pmpi_attr_put = ompi_attr_put_f
 #pragma weak pmpi_attr_put_ = ompi_attr_put_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ATTR_PUT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ATTR_PUT = ompi_attr_put_f
 #pragma weak mpi_attr_put = ompi_attr_put_f
 #pragma weak mpi_attr_put_ = ompi_attr_put_f
diff --git a/ompi/mpi/fortran/mpif-h/barrier_f.c b/ompi/mpi/fortran/mpif-h/barrier_f.c
index 2304b400897..de6d830016b 100644
--- a/ompi/mpi/fortran/mpif-h/barrier_f.c
+++ b/ompi/mpi/fortran/mpif-h/barrier_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BARRIER = ompi_barrier_f
 #pragma weak pmpi_barrier = ompi_barrier_f
 #pragma weak pmpi_barrier_ = ompi_barrier_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BARRIER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BARRIER = ompi_barrier_f
 #pragma weak mpi_barrier = ompi_barrier_f
 #pragma weak mpi_barrier_ = ompi_barrier_f
diff --git a/ompi/mpi/fortran/mpif-h/barrier_init_f.c b/ompi/mpi/fortran/mpif-h/barrier_init_f.c
index f82ac1df1c8..4b27fdbd9a1 100644
--- a/ompi/mpi/fortran/mpif-h/barrier_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/barrier_init_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BARRIER_INIT = ompi_barrier_init_f
 #pragma weak pmpi_barrier_init = ompi_barrier_init_f
 #pragma weak pmpi_barrier_init_ = ompi_barrier_init_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BARRIER_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BARRIER_INIT = ompi_barrier_init_f
 #pragma weak mpi_barrier_init = ompi_barrier_init_f
 #pragma weak mpi_barrier_init_ = ompi_barrier_init_f
diff --git a/ompi/mpi/fortran/mpif-h/bcast_f.c b/ompi/mpi/fortran/mpif-h/bcast_f.c
index 72e8f37faf9..01165152d8a 100644
--- a/ompi/mpi/fortran/mpif-h/bcast_f.c
+++ b/ompi/mpi/fortran/mpif-h/bcast_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BCAST = ompi_bcast_f
 #pragma weak pmpi_bcast = ompi_bcast_f
 #pragma weak pmpi_bcast_ = ompi_bcast_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BCAST,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BCAST = ompi_bcast_f
 #pragma weak mpi_bcast = ompi_bcast_f
 #pragma weak mpi_bcast_ = ompi_bcast_f
diff --git a/ompi/mpi/fortran/mpif-h/bcast_init_f.c b/ompi/mpi/fortran/mpif-h/bcast_init_f.c
index 8cd12934870..d912aeeb10c 100644
--- a/ompi/mpi/fortran/mpif-h/bcast_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/bcast_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BCAST_INIT = ompi_bcast_init_f
 #pragma weak pmpi_bcast_init = ompi_bcast_init_f
 #pragma weak pmpi_bcast_init_ = ompi_bcast_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BCAST_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BCAST_INIT = ompi_bcast_init_f
 #pragma weak mpi_bcast_init = ompi_bcast_init_f
 #pragma weak mpi_bcast_init_ = ompi_bcast_init_f
diff --git a/ompi/mpi/fortran/mpif-h/bsend_f.c b/ompi/mpi/fortran/mpif-h/bsend_f.c
index 5474a33a8e2..cf5ac252d9f 100644
--- a/ompi/mpi/fortran/mpif-h/bsend_f.c
+++ b/ompi/mpi/fortran/mpif-h/bsend_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BSEND = ompi_bsend_f
 #pragma weak pmpi_bsend = ompi_bsend_f
 #pragma weak pmpi_bsend_ = ompi_bsend_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BSEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BSEND = ompi_bsend_f
 #pragma weak mpi_bsend = ompi_bsend_f
 #pragma weak mpi_bsend_ = ompi_bsend_f
diff --git a/ompi/mpi/fortran/mpif-h/bsend_init_f.c b/ompi/mpi/fortran/mpif-h/bsend_init_f.c
index 8a7e9eda6e8..f81425a1b1c 100644
--- a/ompi/mpi/fortran/mpif-h/bsend_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/bsend_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BSEND_INIT = ompi_bsend_init_f
 #pragma weak pmpi_bsend_init = ompi_bsend_init_f
 #pragma weak pmpi_bsend_init_ = ompi_bsend_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BSEND_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BSEND_INIT = ompi_bsend_init_f
 #pragma weak mpi_bsend_init = ompi_bsend_init_f
 #pragma weak mpi_bsend_init_ = ompi_bsend_init_f
diff --git a/ompi/mpi/fortran/mpif-h/buffer_attach_f.c b/ompi/mpi/fortran/mpif-h/buffer_attach_f.c
index f3eaf966343..33b50a35a39 100644
--- a/ompi/mpi/fortran/mpif-h/buffer_attach_f.c
+++ b/ompi/mpi/fortran/mpif-h/buffer_attach_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BUFFER_ATTACH = ompi_buffer_attach_f
 #pragma weak pmpi_buffer_attach = ompi_buffer_attach_f
 #pragma weak pmpi_buffer_attach_ = ompi_buffer_attach_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BUFFER_ATTACH,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BUFFER_ATTACH = ompi_buffer_attach_f
 #pragma weak mpi_buffer_attach = ompi_buffer_attach_f
 #pragma weak mpi_buffer_attach_ = ompi_buffer_attach_f
diff --git a/ompi/mpi/fortran/mpif-h/buffer_detach_f.c b/ompi/mpi/fortran/mpif-h/buffer_detach_f.c
index a1ed3513c61..de374c128a4 100644
--- a/ompi/mpi/fortran/mpif-h/buffer_detach_f.c
+++ b/ompi/mpi/fortran/mpif-h/buffer_detach_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BUFFER_DETACH = ompi_buffer_detach_f
 #pragma weak pmpi_buffer_detach = ompi_buffer_detach_f
 #pragma weak pmpi_buffer_detach_ = ompi_buffer_detach_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BUFFER_DETACH,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BUFFER_DETACH = ompi_buffer_detach_f
 #pragma weak mpi_buffer_detach = ompi_buffer_detach_f
 #pragma weak mpi_buffer_detach_ = ompi_buffer_detach_f
@@ -74,7 +74,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_BUFFER_DETACH,
  * The mpi_f08 implementation for MPI_BUFFER_DETACH therefore is a
  * separate routine in the use-mpi-f08 directory (it's not built in
  * the mpif-h directory because of all the different combinations of
- * supporting weak symbols (or not), building the profiling layer (or
+ * supporting weak aliases (or not), building the profiling layer (or
  * not), etc.).
  */
 void ompi_buffer_detach_f(char *buffer, MPI_Fint *size, MPI_Fint *ierr)
diff --git a/ompi/mpi/fortran/mpif-h/buffer_flush_f.c b/ompi/mpi/fortran/mpif-h/buffer_flush_f.c
index 52c1b868364..15c33d74658 100644
--- a/ompi/mpi/fortran/mpif-h/buffer_flush_f.c
+++ b/ompi/mpi/fortran/mpif-h/buffer_flush_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BUFFER_FLUSH = ompi_buffer_flush_f
 #pragma weak pmpi_buffer_flush = ompi_buffer_flush_f
 #pragma weak pmpi_buffer_flush_ = ompi_buffer_flush_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BUFFER_FLUSH,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BUFFER_FLUSH = ompi_buffer_flush_f
 #pragma weak mpi_buffer_flush = ompi_buffer_flush_f
 #pragma weak mpi_buffer_flush_ = ompi_buffer_flush_f
diff --git a/ompi/mpi/fortran/mpif-h/buffer_iflush_f.c b/ompi/mpi/fortran/mpif-h/buffer_iflush_f.c
index 6a97088933a..0afb8d4115d 100644
--- a/ompi/mpi/fortran/mpif-h/buffer_iflush_f.c
+++ b/ompi/mpi/fortran/mpif-h/buffer_iflush_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_BUFFER_IFLUSH = ompi_buffer_iflush_f
 #pragma weak pmpi_buffer_iflush = ompi_buffer_iflush_f
 #pragma weak pmpi_buffer_iflush_ = ompi_buffer_iflush_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_BUFFER_IFLUSH,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_BUFFER_IFLUSH = ompi_buffer_iflush_f
 #pragma weak mpi_buffer_iflush = ompi_buffer_iflush_f
 #pragma weak mpi_buffer_iflush_ = ompi_buffer_iflush_f
diff --git a/ompi/mpi/fortran/mpif-h/cancel_f.c b/ompi/mpi/fortran/mpif-h/cancel_f.c
index ded928b8a3d..645fdce7320 100644
--- a/ompi/mpi/fortran/mpif-h/cancel_f.c
+++ b/ompi/mpi/fortran/mpif-h/cancel_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CANCEL = ompi_cancel_f
 #pragma weak pmpi_cancel = ompi_cancel_f
 #pragma weak pmpi_cancel_ = ompi_cancel_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CANCEL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CANCEL = ompi_cancel_f
 #pragma weak mpi_cancel = ompi_cancel_f
 #pragma weak mpi_cancel_ = ompi_cancel_f
@@ -62,7 +62,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_CANCEL,
                            (request, ierr) )
 #endif
 
-#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_SYMBOLS
+#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_ALIASES
 #define ompi_cancel_f pompi_cancel_f
 #endif
 #endif
diff --git a/ompi/mpi/fortran/mpif-h/cart_coords_f.c b/ompi/mpi/fortran/mpif-h/cart_coords_f.c
index 311ff6a24f5..426d9883b9a 100644
--- a/ompi/mpi/fortran/mpif-h/cart_coords_f.c
+++ b/ompi/mpi/fortran/mpif-h/cart_coords_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CART_COORDS = ompi_cart_coords_f
 #pragma weak pmpi_cart_coords = ompi_cart_coords_f
 #pragma weak pmpi_cart_coords_ = ompi_cart_coords_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CART_COORDS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CART_COORDS = ompi_cart_coords_f
 #pragma weak mpi_cart_coords = ompi_cart_coords_f
 #pragma weak mpi_cart_coords_ = ompi_cart_coords_f
diff --git a/ompi/mpi/fortran/mpif-h/cart_create_f.c b/ompi/mpi/fortran/mpif-h/cart_create_f.c
index a617ef0c2e4..e7b46636999 100644
--- a/ompi/mpi/fortran/mpif-h/cart_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/cart_create_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CART_CREATE = ompi_cart_create_f
 #pragma weak pmpi_cart_create = ompi_cart_create_f
 #pragma weak pmpi_cart_create_ = ompi_cart_create_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CART_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CART_CREATE = ompi_cart_create_f
 #pragma weak mpi_cart_create = ompi_cart_create_f
 #pragma weak mpi_cart_create_ = ompi_cart_create_f
diff --git a/ompi/mpi/fortran/mpif-h/cart_get_f.c b/ompi/mpi/fortran/mpif-h/cart_get_f.c
index 4517c12e038..6d15b286a67 100644
--- a/ompi/mpi/fortran/mpif-h/cart_get_f.c
+++ b/ompi/mpi/fortran/mpif-h/cart_get_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CART_GET = ompi_cart_get_f
 #pragma weak pmpi_cart_get = ompi_cart_get_f
 #pragma weak pmpi_cart_get_ = ompi_cart_get_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CART_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CART_GET = ompi_cart_get_f
 #pragma weak mpi_cart_get = ompi_cart_get_f
 #pragma weak mpi_cart_get_ = ompi_cart_get_f
diff --git a/ompi/mpi/fortran/mpif-h/cart_map_f.c b/ompi/mpi/fortran/mpif-h/cart_map_f.c
index 6557c89191e..6168330db9b 100644
--- a/ompi/mpi/fortran/mpif-h/cart_map_f.c
+++ b/ompi/mpi/fortran/mpif-h/cart_map_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CART_MAP = ompi_cart_map_f
 #pragma weak pmpi_cart_map = ompi_cart_map_f
 #pragma weak pmpi_cart_map_ = ompi_cart_map_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CART_MAP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CART_MAP = ompi_cart_map_f
 #pragma weak mpi_cart_map = ompi_cart_map_f
 #pragma weak mpi_cart_map_ = ompi_cart_map_f
diff --git a/ompi/mpi/fortran/mpif-h/cart_rank_f.c b/ompi/mpi/fortran/mpif-h/cart_rank_f.c
index e6375db0029..18f3bb80272 100644
--- a/ompi/mpi/fortran/mpif-h/cart_rank_f.c
+++ b/ompi/mpi/fortran/mpif-h/cart_rank_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CART_RANK = ompi_cart_rank_f
 #pragma weak pmpi_cart_rank = ompi_cart_rank_f
 #pragma weak pmpi_cart_rank_ = ompi_cart_rank_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CART_RANK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CART_RANK = ompi_cart_rank_f
 #pragma weak mpi_cart_rank = ompi_cart_rank_f
 #pragma weak mpi_cart_rank_ = ompi_cart_rank_f
diff --git a/ompi/mpi/fortran/mpif-h/cart_shift_f.c b/ompi/mpi/fortran/mpif-h/cart_shift_f.c
index 2b29078b76c..2515f5e8eb9 100644
--- a/ompi/mpi/fortran/mpif-h/cart_shift_f.c
+++ b/ompi/mpi/fortran/mpif-h/cart_shift_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CART_SHIFT = ompi_cart_shift_f
 #pragma weak pmpi_cart_shift = ompi_cart_shift_f
 #pragma weak pmpi_cart_shift_ = ompi_cart_shift_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CART_SHIFT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CART_SHIFT = ompi_cart_shift_f
 #pragma weak mpi_cart_shift = ompi_cart_shift_f
 #pragma weak mpi_cart_shift_ = ompi_cart_shift_f
diff --git a/ompi/mpi/fortran/mpif-h/cart_sub_f.c b/ompi/mpi/fortran/mpif-h/cart_sub_f.c
index 463c96df10e..fe9b0074bed 100644
--- a/ompi/mpi/fortran/mpif-h/cart_sub_f.c
+++ b/ompi/mpi/fortran/mpif-h/cart_sub_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CART_SUB = ompi_cart_sub_f
 #pragma weak pmpi_cart_sub = ompi_cart_sub_f
 #pragma weak pmpi_cart_sub_ = ompi_cart_sub_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CART_SUB,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CART_SUB = ompi_cart_sub_f
 #pragma weak mpi_cart_sub = ompi_cart_sub_f
 #pragma weak mpi_cart_sub_ = ompi_cart_sub_f
diff --git a/ompi/mpi/fortran/mpif-h/cartdim_get_f.c b/ompi/mpi/fortran/mpif-h/cartdim_get_f.c
index d4766d0d3b7..3fcad005aa0 100644
--- a/ompi/mpi/fortran/mpif-h/cartdim_get_f.c
+++ b/ompi/mpi/fortran/mpif-h/cartdim_get_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CARTDIM_GET = ompi_cartdim_get_f
 #pragma weak pmpi_cartdim_get = ompi_cartdim_get_f
 #pragma weak pmpi_cartdim_get_ = ompi_cartdim_get_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CARTDIM_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CARTDIM_GET = ompi_cartdim_get_f
 #pragma weak mpi_cartdim_get = ompi_cartdim_get_f
 #pragma weak mpi_cartdim_get_ = ompi_cartdim_get_f
diff --git a/ompi/mpi/fortran/mpif-h/close_port_f.c b/ompi/mpi/fortran/mpif-h/close_port_f.c
index 434b33ac9b6..61593252d61 100644
--- a/ompi/mpi/fortran/mpif-h/close_port_f.c
+++ b/ompi/mpi/fortran/mpif-h/close_port_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_CLOSE_PORT = ompi_close_port_f
 #pragma weak pmpi_close_port = ompi_close_port_f
 #pragma weak pmpi_close_port_ = ompi_close_port_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_CLOSE_PORT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_CLOSE_PORT = ompi_close_port_f
 #pragma weak mpi_close_port = ompi_close_port_f
 #pragma weak mpi_close_port_ = ompi_close_port_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_accept_f.c b/ompi/mpi/fortran/mpif-h/comm_accept_f.c
index 2e25674bbb9..7ebebadf6d1 100644
--- a/ompi/mpi/fortran/mpif-h/comm_accept_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_accept_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_ACCEPT = ompi_comm_accept_f
 #pragma weak pmpi_comm_accept = ompi_comm_accept_f
 #pragma weak pmpi_comm_accept_ = ompi_comm_accept_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_ACCEPT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_ACCEPT = ompi_comm_accept_f
 #pragma weak mpi_comm_accept = ompi_comm_accept_f
 #pragma weak mpi_comm_accept_ = ompi_comm_accept_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_attach_buffer_f.c b/ompi/mpi/fortran/mpif-h/comm_attach_buffer_f.c
index d104048dd6c..3a48f1425e4 100644
--- a/ompi/mpi/fortran/mpif-h/comm_attach_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_attach_buffer_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_ATTACH_BUFFER = ompi_comm_attach_buffer_f
 #pragma weak pmpi_comm_attach_buffer = ompi_comm_attach_buffer_f
 #pragma weak pmpi_comm_attach_buffer_ = ompi_comm_attach_buffer_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_ATTACH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_ATTACH_BUFFER = ompi_comm_attach_buffer_f
 #pragma weak mpi_comm_attach_buffer = ompi_comm_attach_buffer_f
 #pragma weak mpi_comm_attach_buffer_ = ompi_comm_attach_buffer_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_call_errhandler_f.c b/ompi/mpi/fortran/mpif-h/comm_call_errhandler_f.c
index a5d35ae4d34..d86496c9bac 100644
--- a/ompi/mpi/fortran/mpif-h/comm_call_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_call_errhandler_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_CALL_ERRHANDLER = ompi_comm_call_errhandler_f
 #pragma weak pmpi_comm_call_errhandler = ompi_comm_call_errhandler_f
 #pragma weak pmpi_comm_call_errhandler_ = ompi_comm_call_errhandler_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_CALL_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_CALL_ERRHANDLER = ompi_comm_call_errhandler_f
 #pragma weak mpi_comm_call_errhandler = ompi_comm_call_errhandler_f
 #pragma weak mpi_comm_call_errhandler_ = ompi_comm_call_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_compare_f.c b/ompi/mpi/fortran/mpif-h/comm_compare_f.c
index 332e74ba8ac..f7560b16e19 100644
--- a/ompi/mpi/fortran/mpif-h/comm_compare_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_compare_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_COMPARE = ompi_comm_compare_f
 #pragma weak pmpi_comm_compare = ompi_comm_compare_f
 #pragma weak pmpi_comm_compare_ = ompi_comm_compare_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_COMPARE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_COMPARE = ompi_comm_compare_f
 #pragma weak mpi_comm_compare = ompi_comm_compare_f
 #pragma weak mpi_comm_compare_ = ompi_comm_compare_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_connect_f.c b/ompi/mpi/fortran/mpif-h/comm_connect_f.c
index 6e3092c6d0f..bb4242482da 100644
--- a/ompi/mpi/fortran/mpif-h/comm_connect_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_connect_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_CONNECT = ompi_comm_connect_f
 #pragma weak pmpi_comm_connect = ompi_comm_connect_f
 #pragma weak pmpi_comm_connect_ = ompi_comm_connect_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_CONNECT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_CONNECT = ompi_comm_connect_f
 #pragma weak mpi_comm_connect = ompi_comm_connect_f
 #pragma weak mpi_comm_connect_ = ompi_comm_connect_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_create_errhandler_f.c b/ompi/mpi/fortran/mpif-h/comm_create_errhandler_f.c
index 9881590dd11..e55321b7b0b 100644
--- a/ompi/mpi/fortran/mpif-h/comm_create_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_create_errhandler_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_CREATE_ERRHANDLER = ompi_comm_create_errhandler_f
 #pragma weak pmpi_comm_create_errhandler = ompi_comm_create_errhandler_f
 #pragma weak pmpi_comm_create_errhandler_ = ompi_comm_create_errhandler_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_CREATE_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_CREATE_ERRHANDLER = ompi_comm_create_errhandler_f
 #pragma weak mpi_comm_create_errhandler = ompi_comm_create_errhandler_f
 #pragma weak mpi_comm_create_errhandler_ = ompi_comm_create_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_create_f.c b/ompi/mpi/fortran/mpif-h/comm_create_f.c
index b40f1237863..83f7bf43ba0 100644
--- a/ompi/mpi/fortran/mpif-h/comm_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_create_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_CREATE = ompi_comm_create_f
 #pragma weak pmpi_comm_create = ompi_comm_create_f
 #pragma weak pmpi_comm_create_ = ompi_comm_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_CREATE = ompi_comm_create_f
 #pragma weak mpi_comm_create = ompi_comm_create_f
 #pragma weak mpi_comm_create_ = ompi_comm_create_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_create_from_group_f.c b/ompi/mpi/fortran/mpif-h/comm_create_from_group_f.c
index 5afba43fbf6..b8b41b4e70e 100644
--- a/ompi/mpi/fortran/mpif-h/comm_create_from_group_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_create_from_group_f.c
@@ -34,7 +34,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_CREATE_FROM_GROUP = ompi_comm_create_from_group_f
 #pragma weak pmpi_comm_create_from_group = ompi_comm_create_from_group_f
 #pragma weak pmpi_comm_create_from_group_ = ompi_comm_create_from_group_f
@@ -53,7 +53,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_CREATE_FROM_GROUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_CREATE_FROM_GROUP = ompi_comm_create_from_group_f
 #pragma weak mpi_comm_create_from_group = ompi_comm_create_from_group_f
 #pragma weak mpi_comm_create_from_group_ = ompi_comm_create_from_group_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_create_group_f.c b/ompi/mpi/fortran/mpif-h/comm_create_group_f.c
index 4f8f26eaec3..2d492fa3c36 100644
--- a/ompi/mpi/fortran/mpif-h/comm_create_group_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_create_group_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_CREATE_GROUP = ompi_comm_create_group_f
 #pragma weak pmpi_comm_create_group = ompi_comm_create_group_f
 #pragma weak pmpi_comm_create_group_ = ompi_comm_create_group_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_CREATE_GROUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_CREATE_GROUP = ompi_comm_create_group_f
 #pragma weak mpi_comm_create_group = ompi_comm_create_group_f
 #pragma weak mpi_comm_create_group_ = ompi_comm_create_group_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_create_keyval_f.c b/ompi/mpi/fortran/mpif-h/comm_create_keyval_f.c
index fb069b7a47e..eca6ba720c9 100644
--- a/ompi/mpi/fortran/mpif-h/comm_create_keyval_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_create_keyval_f.c
@@ -25,7 +25,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_CREATE_KEYVAL = ompi_comm_create_keyval_f
 #pragma weak pmpi_comm_create_keyval = ompi_comm_create_keyval_f
 #pragma weak pmpi_comm_create_keyval_ = ompi_comm_create_keyval_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS(PMPI_COMM_CREATE_KEYVAL, pmpi_comm_create_keyval,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_CREATE_KEYVAL = ompi_comm_create_keyval_f
 #pragma weak mpi_comm_create_keyval = ompi_comm_create_keyval_f
 #pragma weak mpi_comm_create_keyval_ = ompi_comm_create_keyval_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_delete_attr_f.c b/ompi/mpi/fortran/mpif-h/comm_delete_attr_f.c
index 86ad48d94c4..e7c0f331f15 100644
--- a/ompi/mpi/fortran/mpif-h/comm_delete_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_delete_attr_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_DELETE_ATTR = ompi_comm_delete_attr_f
 #pragma weak pmpi_comm_delete_attr = ompi_comm_delete_attr_f
 #pragma weak pmpi_comm_delete_attr_ = ompi_comm_delete_attr_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_DELETE_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_DELETE_ATTR = ompi_comm_delete_attr_f
 #pragma weak mpi_comm_delete_attr = ompi_comm_delete_attr_f
 #pragma weak mpi_comm_delete_attr_ = ompi_comm_delete_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_detach_buffer_f.c b/ompi/mpi/fortran/mpif-h/comm_detach_buffer_f.c
index f0776c0e12a..c0acda81855 100644
--- a/ompi/mpi/fortran/mpif-h/comm_detach_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_detach_buffer_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_DETACH_BUFFER = ompi_comm_detach_buffer_f
 #pragma weak pmpi_comm_detach_buffer = ompi_comm_detach_buffer_f
 #pragma weak pmpi_comm_detach_buffer_ = ompi_comm_detach_buffer_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_DETACH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_DETACH_BUFFER = ompi_comm_detach_buffer_f
 #pragma weak mpi_comm_detach_buffer = ompi_comm_detach_buffer_f
 #pragma weak mpi_comm_detach_buffer_ = ompi_comm_detach_buffer_f
@@ -75,7 +75,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_COMM_DETACH_BUFFER,
  * The mpi_f08 implementation for MPI_BUFFER_DETACH therefore is a
  * separate routine in the use-mpi-f08 directory (it's not built in
  * the mpif-h directory because of all the different combinations of
- * supporting weak symbols (or not), building the profiling layer (or
+ * supporting weak aliases (or not), building the profiling layer (or
  * not), etc.).
  */
 void ompi_comm_detach_buffer_f(MPI_Fint *comm, char *buffer, MPI_Fint *size, MPI_Fint *ierr)
diff --git a/ompi/mpi/fortran/mpif-h/comm_disconnect_f.c b/ompi/mpi/fortran/mpif-h/comm_disconnect_f.c
index 9aefb1ca417..a223b09ca16 100644
--- a/ompi/mpi/fortran/mpif-h/comm_disconnect_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_disconnect_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_DISCONNECT = ompi_comm_disconnect_f
 #pragma weak pmpi_comm_disconnect = ompi_comm_disconnect_f
 #pragma weak pmpi_comm_disconnect_ = ompi_comm_disconnect_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_DISCONNECT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_DISCONNECT = ompi_comm_disconnect_f
 #pragma weak mpi_comm_disconnect = ompi_comm_disconnect_f
 #pragma weak mpi_comm_disconnect_ = ompi_comm_disconnect_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_dup_f.c b/ompi/mpi/fortran/mpif-h/comm_dup_f.c
index 8e9da075a98..d2d7ab153af 100644
--- a/ompi/mpi/fortran/mpif-h/comm_dup_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_dup_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_DUP = ompi_comm_dup_f
 #pragma weak pmpi_comm_dup = ompi_comm_dup_f
 #pragma weak pmpi_comm_dup_ = ompi_comm_dup_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_DUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_DUP = ompi_comm_dup_f
 #pragma weak mpi_comm_dup = ompi_comm_dup_f
 #pragma weak mpi_comm_dup_ = ompi_comm_dup_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_dup_with_info_f.c b/ompi/mpi/fortran/mpif-h/comm_dup_with_info_f.c
index 40d989ffda2..5308427b071 100644
--- a/ompi/mpi/fortran/mpif-h/comm_dup_with_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_dup_with_info_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_DUP_WITH_INFO = ompi_comm_dup_with_info_f
 #pragma weak pmpi_comm_dup_with_info = ompi_comm_dup_with_info_f
 #pragma weak pmpi_comm_dup_with_info_ = ompi_comm_dup_with_info_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_DUP_WITH_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_DUP_WITH_INFO = ompi_comm_dup_with_info_f
 #pragma weak mpi_comm_dup_with_info = ompi_comm_dup_with_info_f
 #pragma weak mpi_comm_dup_with_info_ = ompi_comm_dup_with_info_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_flush_buffer_f.c b/ompi/mpi/fortran/mpif-h/comm_flush_buffer_f.c
index 0e5f5f3df08..5ce41f12830 100644
--- a/ompi/mpi/fortran/mpif-h/comm_flush_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_flush_buffer_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_FLUSH_BUFFER = ompi_comm_flush_buffer_f
 #pragma weak pmpi_comm_flush_buffer = ompi_comm_flush_buffer_f
 #pragma weak pmpi_comm_flush_buffer_ = ompi_comm_flush_buffer_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_FLUSH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_FLUSH_BUFFER = ompi_comm_flush_buffer_f
 #pragma weak mpi_comm_flush_buffer = ompi_comm_flush_buffer_f
 #pragma weak mpi_comm_flush_buffer_ = ompi_comm_flush_buffer_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_free_f.c b/ompi/mpi/fortran/mpif-h/comm_free_f.c
index f2e2f4aa20f..c51c2d616dc 100644
--- a/ompi/mpi/fortran/mpif-h/comm_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_FREE = ompi_comm_free_f
 #pragma weak pmpi_comm_free = ompi_comm_free_f
 #pragma weak pmpi_comm_free_ = ompi_comm_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_FREE = ompi_comm_free_f
 #pragma weak mpi_comm_free = ompi_comm_free_f
 #pragma weak mpi_comm_free_ = ompi_comm_free_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_free_keyval_f.c b/ompi/mpi/fortran/mpif-h/comm_free_keyval_f.c
index a66cea6caf4..324bdd4de32 100644
--- a/ompi/mpi/fortran/mpif-h/comm_free_keyval_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_free_keyval_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_FREE_KEYVAL = ompi_comm_free_keyval_f
 #pragma weak pmpi_comm_free_keyval = ompi_comm_free_keyval_f
 #pragma weak pmpi_comm_free_keyval_ = ompi_comm_free_keyval_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_FREE_KEYVAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_FREE_KEYVAL = ompi_comm_free_keyval_f
 #pragma weak mpi_comm_free_keyval = ompi_comm_free_keyval_f
 #pragma weak mpi_comm_free_keyval_ = ompi_comm_free_keyval_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_get_attr_f.c b/ompi/mpi/fortran/mpif-h/comm_get_attr_f.c
index 1253256e941..0146eb9d3ae 100644
--- a/ompi/mpi/fortran/mpif-h/comm_get_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_get_attr_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_GET_ATTR = ompi_comm_get_attr_f
 #pragma weak pmpi_comm_get_attr = ompi_comm_get_attr_f
 #pragma weak pmpi_comm_get_attr_ = ompi_comm_get_attr_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_GET_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_GET_ATTR = ompi_comm_get_attr_f
 #pragma weak mpi_comm_get_attr = ompi_comm_get_attr_f
 #pragma weak mpi_comm_get_attr_ = ompi_comm_get_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_get_errhandler_f.c b/ompi/mpi/fortran/mpif-h/comm_get_errhandler_f.c
index c3c37d3ff4d..5cdddcf4147 100644
--- a/ompi/mpi/fortran/mpif-h/comm_get_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_get_errhandler_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_GET_ERRHANDLER = ompi_comm_get_errhandler_f
 #pragma weak pmpi_comm_get_errhandler = ompi_comm_get_errhandler_f
 #pragma weak pmpi_comm_get_errhandler_ = ompi_comm_get_errhandler_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_GET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_GET_ERRHANDLER = ompi_comm_get_errhandler_f
 #pragma weak mpi_comm_get_errhandler = ompi_comm_get_errhandler_f
 #pragma weak mpi_comm_get_errhandler_ = ompi_comm_get_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_get_info_f.c b/ompi/mpi/fortran/mpif-h/comm_get_info_f.c
index 109fb590de4..95450512b0c 100644
--- a/ompi/mpi/fortran/mpif-h/comm_get_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_get_info_f.c
@@ -16,7 +16,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_GET_INFO = ompi_comm_get_info_f
 #pragma weak pmpi_comm_get_info = ompi_comm_get_info_f
 #pragma weak pmpi_comm_get_info_ = ompi_comm_get_info_f
@@ -35,7 +35,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_GET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_GET_INFO = ompi_comm_get_info_f
 #pragma weak mpi_comm_get_info = ompi_comm_get_info_f
 #pragma weak mpi_comm_get_info_ = ompi_comm_get_info_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_get_name_f.c b/ompi/mpi/fortran/mpif-h/comm_get_name_f.c
index 59d2808d441..9562c1d0907 100644
--- a/ompi/mpi/fortran/mpif-h/comm_get_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_get_name_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_GET_NAME = ompi_comm_get_name_f
 #pragma weak pmpi_comm_get_name = ompi_comm_get_name_f
 #pragma weak pmpi_comm_get_name_ = ompi_comm_get_name_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_GET_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_GET_NAME = ompi_comm_get_name_f
 #pragma weak mpi_comm_get_name = ompi_comm_get_name_f
 #pragma weak mpi_comm_get_name_ = ompi_comm_get_name_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_get_parent_f.c b/ompi/mpi/fortran/mpif-h/comm_get_parent_f.c
index 951e392507c..924d92f06c9 100644
--- a/ompi/mpi/fortran/mpif-h/comm_get_parent_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_get_parent_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_GET_PARENT = ompi_comm_get_parent_f
 #pragma weak pmpi_comm_get_parent = ompi_comm_get_parent_f
 #pragma weak pmpi_comm_get_parent_ = ompi_comm_get_parent_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_GET_PARENT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_GET_PARENT = ompi_comm_get_parent_f
 #pragma weak mpi_comm_get_parent = ompi_comm_get_parent_f
 #pragma weak mpi_comm_get_parent_ = ompi_comm_get_parent_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_group_f.c b/ompi/mpi/fortran/mpif-h/comm_group_f.c
index 50c9342b71b..ff51d147396 100644
--- a/ompi/mpi/fortran/mpif-h/comm_group_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_group_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_GROUP = ompi_comm_group_f
 #pragma weak pmpi_comm_group = ompi_comm_group_f
 #pragma weak pmpi_comm_group_ = ompi_comm_group_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_GROUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_GROUP = ompi_comm_group_f
 #pragma weak mpi_comm_group = ompi_comm_group_f
 #pragma weak mpi_comm_group_ = ompi_comm_group_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_idup_f.c b/ompi/mpi/fortran/mpif-h/comm_idup_f.c
index 11330c82f44..662d00b8912 100644
--- a/ompi/mpi/fortran/mpif-h/comm_idup_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_idup_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_IDUP = ompi_comm_idup_f
 #pragma weak pmpi_comm_idup = ompi_comm_idup_f
 #pragma weak pmpi_comm_idup_ = ompi_comm_idup_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_IDUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_IDUP = ompi_comm_idup_f
 #pragma weak mpi_comm_idup = ompi_comm_idup_f
 #pragma weak mpi_comm_idup_ = ompi_comm_idup_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_idup_with_info_f.c b/ompi/mpi/fortran/mpif-h/comm_idup_with_info_f.c
index c021e502ffe..d9bc7667b54 100644
--- a/ompi/mpi/fortran/mpif-h/comm_idup_with_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_idup_with_info_f.c
@@ -30,7 +30,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_IDUP_WITH_INFO = ompi_comm_idup_with_info_f
 #pragma weak pmpi_comm_idup_with_info = ompi_comm_idup_with_info_f
 #pragma weak pmpi_comm_idup_with_info_ = ompi_comm_idup_with_info_f
@@ -49,7 +49,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_IDUP_WITH_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_IDUP_WITH_INFO = ompi_comm_idup_with_info_f
 #pragma weak mpi_comm_idup_with_info = ompi_comm_idup_with_info_f
 #pragma weak mpi_comm_idup_with_info_ = ompi_comm_idup_with_info_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_iflush_buffer_f.c b/ompi/mpi/fortran/mpif-h/comm_iflush_buffer_f.c
index ca49eb7d51d..78c2f9af87f 100644
--- a/ompi/mpi/fortran/mpif-h/comm_iflush_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_iflush_buffer_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_IFLUSH_BUFFER = ompi_comm_iflush_buffer_f
 #pragma weak pmpi_comm_iflush_buffer = ompi_comm_iflush_buffer_f
 #pragma weak pmpi_comm_iflush_buffer_ = ompi_comm_iflush_buffer_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_IFLUSH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_IFLUSH_BUFFER = ompi_comm_iflush_buffer_f
 #pragma weak mpi_comm_iflush_buffer = ompi_comm_iflush_buffer_f
 #pragma weak mpi_comm_iflush_buffer_ = ompi_comm_iflush_buffer_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_join_f.c b/ompi/mpi/fortran/mpif-h/comm_join_f.c
index fa4fa1bdaa4..ae3f220239f 100644
--- a/ompi/mpi/fortran/mpif-h/comm_join_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_join_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_JOIN = ompi_comm_join_f
 #pragma weak pmpi_comm_join = ompi_comm_join_f
 #pragma weak pmpi_comm_join_ = ompi_comm_join_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_JOIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_JOIN = ompi_comm_join_f
 #pragma weak mpi_comm_join = ompi_comm_join_f
 #pragma weak mpi_comm_join_ = ompi_comm_join_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_rank_f.c b/ompi/mpi/fortran/mpif-h/comm_rank_f.c
index 4735707bf91..3cee0a147e2 100644
--- a/ompi/mpi/fortran/mpif-h/comm_rank_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_rank_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_RANK = ompi_comm_rank_f
 #pragma weak pmpi_comm_rank = ompi_comm_rank_f
 #pragma weak pmpi_comm_rank_ = ompi_comm_rank_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_RANK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_RANK = ompi_comm_rank_f
 #pragma weak mpi_comm_rank = ompi_comm_rank_f
 #pragma weak mpi_comm_rank_ = ompi_comm_rank_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_remote_group_f.c b/ompi/mpi/fortran/mpif-h/comm_remote_group_f.c
index b891c18960b..9147c97ae46 100644
--- a/ompi/mpi/fortran/mpif-h/comm_remote_group_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_remote_group_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_REMOTE_GROUP = ompi_comm_remote_group_f
 #pragma weak pmpi_comm_remote_group = ompi_comm_remote_group_f
 #pragma weak pmpi_comm_remote_group_ = ompi_comm_remote_group_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_REMOTE_GROUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_REMOTE_GROUP = ompi_comm_remote_group_f
 #pragma weak mpi_comm_remote_group = ompi_comm_remote_group_f
 #pragma weak mpi_comm_remote_group_ = ompi_comm_remote_group_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_remote_size_f.c b/ompi/mpi/fortran/mpif-h/comm_remote_size_f.c
index 3a27c0e6ac0..147dfefa265 100644
--- a/ompi/mpi/fortran/mpif-h/comm_remote_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_remote_size_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_REMOTE_SIZE = ompi_comm_remote_size_f
 #pragma weak pmpi_comm_remote_size = ompi_comm_remote_size_f
 #pragma weak pmpi_comm_remote_size_ = ompi_comm_remote_size_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_REMOTE_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_REMOTE_SIZE = ompi_comm_remote_size_f
 #pragma weak mpi_comm_remote_size = ompi_comm_remote_size_f
 #pragma weak mpi_comm_remote_size_ = ompi_comm_remote_size_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_set_attr_f.c b/ompi/mpi/fortran/mpif-h/comm_set_attr_f.c
index ad85ab671df..ffcf234a61b 100644
--- a/ompi/mpi/fortran/mpif-h/comm_set_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_set_attr_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SET_ATTR = ompi_comm_set_attr_f
 #pragma weak pmpi_comm_set_attr = ompi_comm_set_attr_f
 #pragma weak pmpi_comm_set_attr_ = ompi_comm_set_attr_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SET_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SET_ATTR = ompi_comm_set_attr_f
 #pragma weak mpi_comm_set_attr = ompi_comm_set_attr_f
 #pragma weak mpi_comm_set_attr_ = ompi_comm_set_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_set_errhandler_f.c b/ompi/mpi/fortran/mpif-h/comm_set_errhandler_f.c
index 857e92aea35..b18c3142c11 100644
--- a/ompi/mpi/fortran/mpif-h/comm_set_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_set_errhandler_f.c
@@ -25,7 +25,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SET_ERRHANDLER = ompi_comm_set_errhandler_f
 #pragma weak pmpi_comm_set_errhandler = ompi_comm_set_errhandler_f
 #pragma weak pmpi_comm_set_errhandler_ = ompi_comm_set_errhandler_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SET_ERRHANDLER = ompi_comm_set_errhandler_f
 #pragma weak mpi_comm_set_errhandler = ompi_comm_set_errhandler_f
 #pragma weak mpi_comm_set_errhandler_ = ompi_comm_set_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_set_info_f.c b/ompi/mpi/fortran/mpif-h/comm_set_info_f.c
index 75b39ed5d1b..7948c913d5a 100644
--- a/ompi/mpi/fortran/mpif-h/comm_set_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_set_info_f.c
@@ -16,7 +16,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SET_INFO = ompi_comm_set_info_f
 #pragma weak pmpi_comm_set_info = ompi_comm_set_info_f
 #pragma weak pmpi_comm_set_info_ = ompi_comm_set_info_f
@@ -35,7 +35,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SET_INFO = ompi_comm_set_info_f
 #pragma weak mpi_comm_set_info = ompi_comm_set_info_f
 #pragma weak mpi_comm_set_info_ = ompi_comm_set_info_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_set_name_f.c b/ompi/mpi/fortran/mpif-h/comm_set_name_f.c
index 6dbffcc9928..2e37d9118e8 100644
--- a/ompi/mpi/fortran/mpif-h/comm_set_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_set_name_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SET_NAME = ompi_comm_set_name_f
 #pragma weak pmpi_comm_set_name = ompi_comm_set_name_f
 #pragma weak pmpi_comm_set_name_ = ompi_comm_set_name_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SET_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SET_NAME = ompi_comm_set_name_f
 #pragma weak mpi_comm_set_name = ompi_comm_set_name_f
 #pragma weak mpi_comm_set_name_ = ompi_comm_set_name_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_size_f.c b/ompi/mpi/fortran/mpif-h/comm_size_f.c
index 429199ba8a9..390a52d1e4a 100644
--- a/ompi/mpi/fortran/mpif-h/comm_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_size_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SIZE = ompi_comm_size_f
 #pragma weak pmpi_comm_size = ompi_comm_size_f
 #pragma weak pmpi_comm_size_ = ompi_comm_size_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SIZE = ompi_comm_size_f
 #pragma weak mpi_comm_size = ompi_comm_size_f
 #pragma weak mpi_comm_size_ = ompi_comm_size_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_spawn_f.c b/ompi/mpi/fortran/mpif-h/comm_spawn_f.c
index e866a9f97d5..2e4f4987c88 100644
--- a/ompi/mpi/fortran/mpif-h/comm_spawn_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_spawn_f.c
@@ -27,7 +27,7 @@
 #include "opal/util/argv.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SPAWN = ompi_comm_spawn_f
 #pragma weak pmpi_comm_spawn = ompi_comm_spawn_f
 #pragma weak pmpi_comm_spawn_ = ompi_comm_spawn_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SPAWN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SPAWN = ompi_comm_spawn_f
 #pragma weak mpi_comm_spawn = ompi_comm_spawn_f
 #pragma weak mpi_comm_spawn_ = ompi_comm_spawn_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_spawn_multiple_f.c b/ompi/mpi/fortran/mpif-h/comm_spawn_multiple_f.c
index fd676539ed3..f7280ec58d1 100644
--- a/ompi/mpi/fortran/mpif-h/comm_spawn_multiple_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_spawn_multiple_f.c
@@ -31,7 +31,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SPAWN_MULTIPLE = ompi_comm_spawn_multiple_f
 #pragma weak pmpi_comm_spawn_multiple = ompi_comm_spawn_multiple_f
 #pragma weak pmpi_comm_spawn_multiple_ = ompi_comm_spawn_multiple_f
@@ -50,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SPAWN_MULTIPLE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SPAWN_MULTIPLE = ompi_comm_spawn_multiple_f
 #pragma weak mpi_comm_spawn_multiple = ompi_comm_spawn_multiple_f
 #pragma weak mpi_comm_spawn_multiple_ = ompi_comm_spawn_multiple_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_split_f.c b/ompi/mpi/fortran/mpif-h/comm_split_f.c
index 614fb96f4d8..c45da2240a1 100644
--- a/ompi/mpi/fortran/mpif-h/comm_split_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_split_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SPLIT = ompi_comm_split_f
 #pragma weak pmpi_comm_split = ompi_comm_split_f
 #pragma weak pmpi_comm_split_ = ompi_comm_split_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SPLIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SPLIT = ompi_comm_split_f
 #pragma weak mpi_comm_split = ompi_comm_split_f
 #pragma weak mpi_comm_split_ = ompi_comm_split_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_split_type_f.c b/ompi/mpi/fortran/mpif-h/comm_split_type_f.c
index b35d45ac06f..70000d98ec1 100644
--- a/ompi/mpi/fortran/mpif-h/comm_split_type_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_split_type_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_SPLIT_TYPE = ompi_comm_split_type_f
 #pragma weak pmpi_comm_split_type = ompi_comm_split_type_f
 #pragma weak pmpi_comm_split_type_ = ompi_comm_split_type_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_SPLIT_TYPE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_SPLIT_TYPE = ompi_comm_split_type_f
 #pragma weak mpi_comm_split_type = ompi_comm_split_type_f
 #pragma weak mpi_comm_split_type_ = ompi_comm_split_type_f
diff --git a/ompi/mpi/fortran/mpif-h/comm_test_inter_f.c b/ompi/mpi/fortran/mpif-h/comm_test_inter_f.c
index 78e2a5cdb5e..b5aab01124e 100644
--- a/ompi/mpi/fortran/mpif-h/comm_test_inter_f.c
+++ b/ompi/mpi/fortran/mpif-h/comm_test_inter_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMM_TEST_INTER = ompi_comm_test_inter_f
 #pragma weak pmpi_comm_test_inter = ompi_comm_test_inter_f
 #pragma weak pmpi_comm_test_inter_ = ompi_comm_test_inter_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMM_TEST_INTER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMM_TEST_INTER = ompi_comm_test_inter_f
 #pragma weak mpi_comm_test_inter = ompi_comm_test_inter_f
 #pragma weak mpi_comm_test_inter_ = ompi_comm_test_inter_f
diff --git a/ompi/mpi/fortran/mpif-h/compare_and_swap_f.c b/ompi/mpi/fortran/mpif-h/compare_and_swap_f.c
index cf6f6a81319..b7c4b273509 100644
--- a/ompi/mpi/fortran/mpif-h/compare_and_swap_f.c
+++ b/ompi/mpi/fortran/mpif-h/compare_and_swap_f.c
@@ -29,7 +29,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_COMPARE_AND_SWAP = ompi_compare_and_swap_f
 #pragma weak pmpi_compare_and_swap = ompi_compare_and_swap_f
 #pragma weak pmpi_compare_and_swap_ = ompi_compare_and_swap_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_COMPARE_AND_SWAP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_COMPARE_AND_SWAP = ompi_compare_and_swap_f
 #pragma weak mpi_compare_and_swap = ompi_compare_and_swap_f
 #pragma weak mpi_compare_and_swap_ = ompi_compare_and_swap_f
diff --git a/ompi/mpi/fortran/mpif-h/dims_create_f.c b/ompi/mpi/fortran/mpif-h/dims_create_f.c
index 7a544af06b1..98cd5313bd6 100644
--- a/ompi/mpi/fortran/mpif-h/dims_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/dims_create_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_DIMS_CREATE = ompi_dims_create_f
 #pragma weak pmpi_dims_create = ompi_dims_create_f
 #pragma weak pmpi_dims_create_ = ompi_dims_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_DIMS_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_DIMS_CREATE = ompi_dims_create_f
 #pragma weak mpi_dims_create = ompi_dims_create_f
 #pragma weak mpi_dims_create_ = ompi_dims_create_f
diff --git a/ompi/mpi/fortran/mpif-h/dist_graph_create_adjacent_f.c b/ompi/mpi/fortran/mpif-h/dist_graph_create_adjacent_f.c
index 1f2e6bc795a..cb0b609473b 100644
--- a/ompi/mpi/fortran/mpif-h/dist_graph_create_adjacent_f.c
+++ b/ompi/mpi/fortran/mpif-h/dist_graph_create_adjacent_f.c
@@ -23,7 +23,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_DIST_GRAPH_CREATE_ADJACENT = ompi_dist_graph_create_adjacent_f
 #pragma weak pmpi_dist_graph_create_adjacent = ompi_dist_graph_create_adjacent_f
 #pragma weak pmpi_dist_graph_create_adjacent_ = ompi_dist_graph_create_adjacent_f
@@ -42,7 +42,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_DIST_GRAPH_CREATE_ADJACENT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_DIST_GRAPH_CREATE_ADJACENT = ompi_dist_graph_create_adjacent_f
 #pragma weak mpi_dist_graph_create_adjacent = ompi_dist_graph_create_adjacent_f
 #pragma weak mpi_dist_graph_create_adjacent_ = ompi_dist_graph_create_adjacent_f
@@ -61,7 +61,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_DIST_GRAPH_CREATE_ADJACENT,
                             (comm_old, indegree,  sources, sourceweights, outdegree, destinations, destweights, info, reorder, comm_graph, ierr) )
 #endif
 
-#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_SYMBOLS
+#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_ALIASES
 #define ompi_dist_graph_create_adjacent_f pompi_dist_graph_create_adjacent_f
 #endif
 #endif
diff --git a/ompi/mpi/fortran/mpif-h/dist_graph_create_f.c b/ompi/mpi/fortran/mpif-h/dist_graph_create_f.c
index d702bdaecf2..99591e372b8 100644
--- a/ompi/mpi/fortran/mpif-h/dist_graph_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/dist_graph_create_f.c
@@ -23,7 +23,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_DIST_GRAPH_CREATE = ompi_dist_graph_create_f
 #pragma weak pmpi_dist_graph_create = ompi_dist_graph_create_f
 #pragma weak pmpi_dist_graph_create_ = ompi_dist_graph_create_f
@@ -42,7 +42,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_DIST_GRAPH_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_DIST_GRAPH_CREATE = ompi_dist_graph_create_f
 #pragma weak mpi_dist_graph_create = ompi_dist_graph_create_f
 #pragma weak mpi_dist_graph_create_ = ompi_dist_graph_create_f
@@ -61,7 +61,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_DIST_GRAPH_CREATE,
                             (comm_old, n, sources, degrees, destinations, weights, info, reorder, comm_graph, ierr) )
 #endif
 
-#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_SYMBOLS
+#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_ALIASES
 #define ompi_dist_graph_create_f pompi_dist_graph_create_f
 #endif
 #endif
diff --git a/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_count_f.c b/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_count_f.c
index aad5aac5f80..d593ea81a07 100644
--- a/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_count_f.c
+++ b/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_count_f.c
@@ -19,7 +19,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_DIST_GRAPH_NEIGHBORS_COUNT = ompi_dist_graph_neighbors_count_f
 #pragma weak pmpi_dist_graph_neighbors_count = ompi_dist_graph_neighbors_count_f
 #pragma weak pmpi_dist_graph_neighbors_count_ = ompi_dist_graph_neighbors_count_f
@@ -38,7 +38,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_DIST_GRAPH_NEIGHBORS_COUNT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_DIST_GRAPH_NEIGHBORS_COUNT = ompi_dist_graph_neighbors_count_f
 #pragma weak mpi_dist_graph_neighbors_count = ompi_dist_graph_neighbors_count_f
 #pragma weak mpi_dist_graph_neighbors_count_ = ompi_dist_graph_neighbors_count_f
diff --git a/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_f.c b/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_f.c
index 556d909ad1d..6a268037dc9 100644
--- a/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_f.c
+++ b/ompi/mpi/fortran/mpif-h/dist_graph_neighbors_f.c
@@ -19,7 +19,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_DIST_GRAPH_NEIGHBORS = ompi_dist_graph_neighbors_f
 #pragma weak pmpi_dist_graph_neighbors = ompi_dist_graph_neighbors_f
 #pragma weak pmpi_dist_graph_neighbors_ = ompi_dist_graph_neighbors_f
@@ -38,7 +38,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_DIST_GRAPH_NEIGHBORS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_DIST_GRAPH_NEIGHBORS = ompi_dist_graph_neighbors_f
 #pragma weak mpi_dist_graph_neighbors = ompi_dist_graph_neighbors_f
 #pragma weak mpi_dist_graph_neighbors_ = ompi_dist_graph_neighbors_f
@@ -57,7 +57,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_DIST_GRAPH_NEIGHBORS,
                             (comm, maxindegree, sources, sourceweights, maxoutdegree, destinations, destweights, ierr) )
 #endif
 
-#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_SYMBOLS
+#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_ALIASES
 #define ompi_dist_graph_neighbors_f pompi_dist_graph_neighbors_f
 #endif
 #endif
diff --git a/ompi/mpi/fortran/mpif-h/errhandler_create_f.c b/ompi/mpi/fortran/mpif-h/errhandler_create_f.c
index 9805f652806..3d8aeb769da 100644
--- a/ompi/mpi/fortran/mpif-h/errhandler_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/errhandler_create_f.c
@@ -25,7 +25,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ERRHANDLER_CREATE = ompi_errhandler_create_f
 #pragma weak pmpi_errhandler_create = ompi_errhandler_create_f
 #pragma weak pmpi_errhandler_create_ = ompi_errhandler_create_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ERRHANDLER_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ERRHANDLER_CREATE = ompi_errhandler_create_f
 #pragma weak mpi_errhandler_create = ompi_errhandler_create_f
 #pragma weak mpi_errhandler_create_ = ompi_errhandler_create_f
diff --git a/ompi/mpi/fortran/mpif-h/errhandler_free_f.c b/ompi/mpi/fortran/mpif-h/errhandler_free_f.c
index cf377540a9d..24fa59924aa 100644
--- a/ompi/mpi/fortran/mpif-h/errhandler_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/errhandler_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ERRHANDLER_FREE = ompi_errhandler_free_f
 #pragma weak pmpi_errhandler_free = ompi_errhandler_free_f
 #pragma weak pmpi_errhandler_free_ = ompi_errhandler_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ERRHANDLER_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ERRHANDLER_FREE = ompi_errhandler_free_f
 #pragma weak mpi_errhandler_free = ompi_errhandler_free_f
 #pragma weak mpi_errhandler_free_ = ompi_errhandler_free_f
diff --git a/ompi/mpi/fortran/mpif-h/errhandler_get_f.c b/ompi/mpi/fortran/mpif-h/errhandler_get_f.c
index 5ca661aa10d..2a6ba596c6e 100644
--- a/ompi/mpi/fortran/mpif-h/errhandler_get_f.c
+++ b/ompi/mpi/fortran/mpif-h/errhandler_get_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ERRHANDLER_GET = ompi_errhandler_get_f
 #pragma weak pmpi_errhandler_get = ompi_errhandler_get_f
 #pragma weak pmpi_errhandler_get_ = ompi_errhandler_get_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ERRHANDLER_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ERRHANDLER_GET = ompi_errhandler_get_f
 #pragma weak mpi_errhandler_get = ompi_errhandler_get_f
 #pragma weak mpi_errhandler_get_ = ompi_errhandler_get_f
diff --git a/ompi/mpi/fortran/mpif-h/errhandler_set_f.c b/ompi/mpi/fortran/mpif-h/errhandler_set_f.c
index d6ea8a94b32..fa6d5d8b512 100644
--- a/ompi/mpi/fortran/mpif-h/errhandler_set_f.c
+++ b/ompi/mpi/fortran/mpif-h/errhandler_set_f.c
@@ -25,7 +25,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ERRHANDLER_SET = ompi_errhandler_set_f
 #pragma weak pmpi_errhandler_set = ompi_errhandler_set_f
 #pragma weak pmpi_errhandler_set_ = ompi_errhandler_set_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ERRHANDLER_SET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ERRHANDLER_SET = ompi_errhandler_set_f
 #pragma weak mpi_errhandler_set = ompi_errhandler_set_f
 #pragma weak mpi_errhandler_set_ = ompi_errhandler_set_f
diff --git a/ompi/mpi/fortran/mpif-h/error_class_f.c b/ompi/mpi/fortran/mpif-h/error_class_f.c
index 77d2c848d14..f049e8cf150 100644
--- a/ompi/mpi/fortran/mpif-h/error_class_f.c
+++ b/ompi/mpi/fortran/mpif-h/error_class_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ERROR_CLASS = ompi_error_class_f
 #pragma weak pmpi_error_class = ompi_error_class_f
 #pragma weak pmpi_error_class_ = ompi_error_class_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ERROR_CLASS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ERROR_CLASS = ompi_error_class_f
 #pragma weak mpi_error_class = ompi_error_class_f
 #pragma weak mpi_error_class_ = ompi_error_class_f
diff --git a/ompi/mpi/fortran/mpif-h/error_string_f.c b/ompi/mpi/fortran/mpif-h/error_string_f.c
index dc0bad251ba..f9ddc2e5c55 100644
--- a/ompi/mpi/fortran/mpif-h/error_string_f.c
+++ b/ompi/mpi/fortran/mpif-h/error_string_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ERROR_STRING = ompi_error_string_f
 #pragma weak pmpi_error_string = ompi_error_string_f
 #pragma weak pmpi_error_string_ = ompi_error_string_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ERROR_STRING,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ERROR_STRING = ompi_error_string_f
 #pragma weak mpi_error_string = ompi_error_string_f
 #pragma weak mpi_error_string_ = ompi_error_string_f
diff --git a/ompi/mpi/fortran/mpif-h/exscan_f.c b/ompi/mpi/fortran/mpif-h/exscan_f.c
index 9880301e2b3..0e532972778 100644
--- a/ompi/mpi/fortran/mpif-h/exscan_f.c
+++ b/ompi/mpi/fortran/mpif-h/exscan_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_EXSCAN = ompi_exscan_f
 #pragma weak pmpi_exscan = ompi_exscan_f
 #pragma weak pmpi_exscan_ = ompi_exscan_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_EXSCAN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_EXSCAN = ompi_exscan_f
 #pragma weak mpi_exscan = ompi_exscan_f
 #pragma weak mpi_exscan_ = ompi_exscan_f
diff --git a/ompi/mpi/fortran/mpif-h/exscan_init_f.c b/ompi/mpi/fortran/mpif-h/exscan_init_f.c
index 142944aa5c5..c30334fa326 100644
--- a/ompi/mpi/fortran/mpif-h/exscan_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/exscan_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_EXSCAN_INIT = ompi_exscan_init_f
 #pragma weak pmpi_exscan_init = ompi_exscan_init_f
 #pragma weak pmpi_exscan_init_ = ompi_exscan_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_EXSCAN_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_EXSCAN_INIT = ompi_exscan_init_f
 #pragma weak mpi_exscan_init = ompi_exscan_init_f
 #pragma weak mpi_exscan_init_ = ompi_exscan_init_f
diff --git a/ompi/mpi/fortran/mpif-h/f_sync_reg_f.c b/ompi/mpi/fortran/mpif-h/f_sync_reg_f.c
index 4b58f023776..1de2d6550e2 100644
--- a/ompi/mpi/fortran/mpif-h/f_sync_reg_f.c
+++ b/ompi/mpi/fortran/mpif-h/f_sync_reg_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_F_SYNC_REG = ompi_f_sync_reg_f
 #pragma weak pmpi_f_sync_reg = ompi_f_sync_reg_f
 #pragma weak pmpi_f_sync_reg_ = ompi_f_sync_reg_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_F_SYNC_REG,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_F_SYNC_REG = ompi_f_sync_reg_f
 #pragma weak mpi_f_sync_reg = ompi_f_sync_reg_f
 #pragma weak mpi_f_sync_reg_ = ompi_f_sync_reg_f
diff --git a/ompi/mpi/fortran/mpif-h/fetch_and_op_f.c b/ompi/mpi/fortran/mpif-h/fetch_and_op_f.c
index 9deac958f7a..30fbe622b22 100644
--- a/ompi/mpi/fortran/mpif-h/fetch_and_op_f.c
+++ b/ompi/mpi/fortran/mpif-h/fetch_and_op_f.c
@@ -29,7 +29,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FETCH_AND_OP = ompi_fetch_and_op_f
 #pragma weak pmpi_fetch_and_op = ompi_fetch_and_op_f
 #pragma weak pmpi_fetch_and_op_ = ompi_fetch_and_op_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FETCH_AND_OP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FETCH_AND_OP = ompi_fetch_and_op_f
 #pragma weak mpi_fetch_and_op = ompi_fetch_and_op_f
 #pragma weak mpi_fetch_and_op_ = ompi_fetch_and_op_f
diff --git a/ompi/mpi/fortran/mpif-h/file_call_errhandler_f.c b/ompi/mpi/fortran/mpif-h/file_call_errhandler_f.c
index d5de8aa2476..d80bd3222f8 100644
--- a/ompi/mpi/fortran/mpif-h/file_call_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_call_errhandler_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_CALL_ERRHANDLER = ompi_file_call_errhandler_f
 #pragma weak pmpi_file_call_errhandler = ompi_file_call_errhandler_f
 #pragma weak pmpi_file_call_errhandler_ = ompi_file_call_errhandler_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_CALL_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_CALL_ERRHANDLER = ompi_file_call_errhandler_f
 #pragma weak mpi_file_call_errhandler = ompi_file_call_errhandler_f
 #pragma weak mpi_file_call_errhandler_ = ompi_file_call_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/file_close_f.c b/ompi/mpi/fortran/mpif-h/file_close_f.c
index 71b343b22a0..d5a66f7b235 100644
--- a/ompi/mpi/fortran/mpif-h/file_close_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_close_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_CLOSE = ompi_file_close_f
 #pragma weak pmpi_file_close = ompi_file_close_f
 #pragma weak pmpi_file_close_ = ompi_file_close_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_CLOSE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_CLOSE = ompi_file_close_f
 #pragma weak mpi_file_close = ompi_file_close_f
 #pragma weak mpi_file_close_ = ompi_file_close_f
diff --git a/ompi/mpi/fortran/mpif-h/file_create_errhandler_f.c b/ompi/mpi/fortran/mpif-h/file_create_errhandler_f.c
index a20af467621..440495b0e15 100644
--- a/ompi/mpi/fortran/mpif-h/file_create_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_create_errhandler_f.c
@@ -26,7 +26,7 @@
 #include "ompi/file/file.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_CREATE_ERRHANDLER = ompi_file_create_errhandler_f
 #pragma weak pmpi_file_create_errhandler = ompi_file_create_errhandler_f
 #pragma weak pmpi_file_create_errhandler_ = ompi_file_create_errhandler_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_CREATE_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_CREATE_ERRHANDLER = ompi_file_create_errhandler_f
 #pragma weak mpi_file_create_errhandler = ompi_file_create_errhandler_f
 #pragma weak mpi_file_create_errhandler_ = ompi_file_create_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/file_delete_f.c b/ompi/mpi/fortran/mpif-h/file_delete_f.c
index 36a6179f0c7..181ff2c932d 100644
--- a/ompi/mpi/fortran/mpif-h/file_delete_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_delete_f.c
@@ -26,7 +26,7 @@
 #include "ompi/file/file.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_DELETE = ompi_file_delete_f
 #pragma weak pmpi_file_delete = ompi_file_delete_f
 #pragma weak pmpi_file_delete_ = ompi_file_delete_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_DELETE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_DELETE = ompi_file_delete_f
 #pragma weak mpi_file_delete = ompi_file_delete_f
 #pragma weak mpi_file_delete_ = ompi_file_delete_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_amode_f.c b/ompi/mpi/fortran/mpif-h/file_get_amode_f.c
index 3c99d14a165..1cb49324cd8 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_amode_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_amode_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_AMODE = ompi_file_get_amode_f
 #pragma weak pmpi_file_get_amode = ompi_file_get_amode_f
 #pragma weak pmpi_file_get_amode_ = ompi_file_get_amode_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_AMODE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_AMODE = ompi_file_get_amode_f
 #pragma weak mpi_file_get_amode = ompi_file_get_amode_f
 #pragma weak mpi_file_get_amode_ = ompi_file_get_amode_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_atomicity_f.c b/ompi/mpi/fortran/mpif-h/file_get_atomicity_f.c
index 76f672c0751..5c2b8844cff 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_atomicity_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_atomicity_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_ATOMICITY = ompi_file_get_atomicity_f
 #pragma weak pmpi_file_get_atomicity = ompi_file_get_atomicity_f
 #pragma weak pmpi_file_get_atomicity_ = ompi_file_get_atomicity_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_ATOMICITY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_ATOMICITY = ompi_file_get_atomicity_f
 #pragma weak mpi_file_get_atomicity = ompi_file_get_atomicity_f
 #pragma weak mpi_file_get_atomicity_ = ompi_file_get_atomicity_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_byte_offset_f.c b/ompi/mpi/fortran/mpif-h/file_get_byte_offset_f.c
index 88b6901d82e..f86dd43b54d 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_byte_offset_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_byte_offset_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_BYTE_OFFSET = ompi_file_get_byte_offset_f
 #pragma weak pmpi_file_get_byte_offset = ompi_file_get_byte_offset_f
 #pragma weak pmpi_file_get_byte_offset_ = ompi_file_get_byte_offset_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_BYTE_OFFSET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_BYTE_OFFSET = ompi_file_get_byte_offset_f
 #pragma weak mpi_file_get_byte_offset = ompi_file_get_byte_offset_f
 #pragma weak mpi_file_get_byte_offset_ = ompi_file_get_byte_offset_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_errhandler_f.c b/ompi/mpi/fortran/mpif-h/file_get_errhandler_f.c
index 3fe15871b22..71e1b610fe0 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_errhandler_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_ERRHANDLER = ompi_file_get_errhandler_f
 #pragma weak pmpi_file_get_errhandler = ompi_file_get_errhandler_f
 #pragma weak pmpi_file_get_errhandler_ = ompi_file_get_errhandler_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_ERRHANDLER = ompi_file_get_errhandler_f
 #pragma weak mpi_file_get_errhandler = ompi_file_get_errhandler_f
 #pragma weak mpi_file_get_errhandler_ = ompi_file_get_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_group_f.c b/ompi/mpi/fortran/mpif-h/file_get_group_f.c
index d844e03ed00..ffeb17f8294 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_group_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_group_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_GROUP = ompi_file_get_group_f
 #pragma weak pmpi_file_get_group = ompi_file_get_group_f
 #pragma weak pmpi_file_get_group_ = ompi_file_get_group_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_GROUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_GROUP = ompi_file_get_group_f
 #pragma weak mpi_file_get_group = ompi_file_get_group_f
 #pragma weak mpi_file_get_group_ = ompi_file_get_group_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_info_f.c b/ompi/mpi/fortran/mpif-h/file_get_info_f.c
index 5daceede9e1..5ab112219da 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_info_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_INFO = ompi_file_get_info_f
 #pragma weak pmpi_file_get_info = ompi_file_get_info_f
 #pragma weak pmpi_file_get_info_ = ompi_file_get_info_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_INFO = ompi_file_get_info_f
 #pragma weak mpi_file_get_info = ompi_file_get_info_f
 #pragma weak mpi_file_get_info_ = ompi_file_get_info_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_position_f.c b/ompi/mpi/fortran/mpif-h/file_get_position_f.c
index 8a5e6178ab3..dd57f2a6968 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_position_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_position_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_POSITION = ompi_file_get_position_f
 #pragma weak pmpi_file_get_position = ompi_file_get_position_f
 #pragma weak pmpi_file_get_position_ = ompi_file_get_position_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_POSITION,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_POSITION = ompi_file_get_position_f
 #pragma weak mpi_file_get_position = ompi_file_get_position_f
 #pragma weak mpi_file_get_position_ = ompi_file_get_position_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_position_shared_f.c b/ompi/mpi/fortran/mpif-h/file_get_position_shared_f.c
index 67a9af73f82..bbca07d35f8 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_position_shared_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_position_shared_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_POSITION_SHARED = ompi_file_get_position_shared_f
 #pragma weak pmpi_file_get_position_shared = ompi_file_get_position_shared_f
 #pragma weak pmpi_file_get_position_shared_ = ompi_file_get_position_shared_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_POSITION_SHARED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_POSITION_SHARED = ompi_file_get_position_shared_f
 #pragma weak mpi_file_get_position_shared = ompi_file_get_position_shared_f
 #pragma weak mpi_file_get_position_shared_ = ompi_file_get_position_shared_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_size_f.c b/ompi/mpi/fortran/mpif-h/file_get_size_f.c
index 90261226887..b7277fed9f8 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_size_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_SIZE = ompi_file_get_size_f
 #pragma weak pmpi_file_get_size = ompi_file_get_size_f
 #pragma weak pmpi_file_get_size_ = ompi_file_get_size_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_SIZE = ompi_file_get_size_f
 #pragma weak mpi_file_get_size = ompi_file_get_size_f
 #pragma weak mpi_file_get_size_ = ompi_file_get_size_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_type_extent_f.c b/ompi/mpi/fortran/mpif-h/file_get_type_extent_f.c
index fef25adb706..6ed43276636 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_type_extent_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_type_extent_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_TYPE_EXTENT = ompi_file_get_type_extent_f
 #pragma weak pmpi_file_get_type_extent = ompi_file_get_type_extent_f
 #pragma weak pmpi_file_get_type_extent_ = ompi_file_get_type_extent_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_TYPE_EXTENT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_TYPE_EXTENT = ompi_file_get_type_extent_f
 #pragma weak mpi_file_get_type_extent = ompi_file_get_type_extent_f
 #pragma weak mpi_file_get_type_extent_ = ompi_file_get_type_extent_f
diff --git a/ompi/mpi/fortran/mpif-h/file_get_view_f.c b/ompi/mpi/fortran/mpif-h/file_get_view_f.c
index 4543337b119..8f48992d0f8 100644
--- a/ompi/mpi/fortran/mpif-h/file_get_view_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_get_view_f.c
@@ -26,7 +26,7 @@
 #include "ompi/file/file.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_GET_VIEW = ompi_file_get_view_f
 #pragma weak pmpi_file_get_view = ompi_file_get_view_f
 #pragma weak pmpi_file_get_view_ = ompi_file_get_view_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_GET_VIEW,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_GET_VIEW = ompi_file_get_view_f
 #pragma weak mpi_file_get_view = ompi_file_get_view_f
 #pragma weak mpi_file_get_view_ = ompi_file_get_view_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iread_all_f.c b/ompi/mpi/fortran/mpif-h/file_iread_all_f.c
index f3ec32c9a85..f4567e33602 100644
--- a/ompi/mpi/fortran/mpif-h/file_iread_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iread_all_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IREAD_ALL = ompi_file_iread_all_f
 #pragma weak pmpi_file_iread_all = ompi_file_iread_all_f
 #pragma weak pmpi_file_iread_all_ = ompi_file_iread_all_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IREAD_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IREAD_ALL = ompi_file_iread_all_f
 #pragma weak mpi_file_iread_all = ompi_file_iread_all_f
 #pragma weak mpi_file_iread_all_ = ompi_file_iread_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iread_at_all_f.c b/ompi/mpi/fortran/mpif-h/file_iread_at_all_f.c
index 2b5730e9b54..5948fa2d99c 100644
--- a/ompi/mpi/fortran/mpif-h/file_iread_at_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iread_at_all_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IREAD_AT_ALL = ompi_file_iread_at_all_f
 #pragma weak pmpi_file_iread_at_all = ompi_file_iread_at_all_f
 #pragma weak pmpi_file_iread_at_all_ = ompi_file_iread_at_all_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IREAD_AT_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IREAD_AT_ALL = ompi_file_iread_at_all_f
 #pragma weak mpi_file_iread_at_all = ompi_file_iread_at_all_f
 #pragma weak mpi_file_iread_at_all_ = ompi_file_iread_at_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iread_at_f.c b/ompi/mpi/fortran/mpif-h/file_iread_at_f.c
index 239f7a3bacb..b1e45ef9dae 100644
--- a/ompi/mpi/fortran/mpif-h/file_iread_at_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iread_at_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IREAD_AT = ompi_file_iread_at_f
 #pragma weak pmpi_file_iread_at = ompi_file_iread_at_f
 #pragma weak pmpi_file_iread_at_ = ompi_file_iread_at_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IREAD_AT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IREAD_AT = ompi_file_iread_at_f
 #pragma weak mpi_file_iread_at = ompi_file_iread_at_f
 #pragma weak mpi_file_iread_at_ = ompi_file_iread_at_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iread_f.c b/ompi/mpi/fortran/mpif-h/file_iread_f.c
index 620eb6890da..3deb970337a 100644
--- a/ompi/mpi/fortran/mpif-h/file_iread_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iread_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IREAD = ompi_file_iread_f
 #pragma weak pmpi_file_iread = ompi_file_iread_f
 #pragma weak pmpi_file_iread_ = ompi_file_iread_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IREAD,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IREAD = ompi_file_iread_f
 #pragma weak mpi_file_iread = ompi_file_iread_f
 #pragma weak mpi_file_iread_ = ompi_file_iread_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iread_shared_f.c b/ompi/mpi/fortran/mpif-h/file_iread_shared_f.c
index bfc105f625f..42507a6cda9 100644
--- a/ompi/mpi/fortran/mpif-h/file_iread_shared_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iread_shared_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IREAD_SHARED = ompi_file_iread_shared_f
 #pragma weak pmpi_file_iread_shared = ompi_file_iread_shared_f
 #pragma weak pmpi_file_iread_shared_ = ompi_file_iread_shared_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IREAD_SHARED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IREAD_SHARED = ompi_file_iread_shared_f
 #pragma weak mpi_file_iread_shared = ompi_file_iread_shared_f
 #pragma weak mpi_file_iread_shared_ = ompi_file_iread_shared_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iwrite_all_f.c b/ompi/mpi/fortran/mpif-h/file_iwrite_all_f.c
index 43368f54167..d494a7b1c75 100644
--- a/ompi/mpi/fortran/mpif-h/file_iwrite_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iwrite_all_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IWRITE_ALL = ompi_file_iwrite_all_f
 #pragma weak pmpi_file_iwrite_all = ompi_file_iwrite_all_f
 #pragma weak pmpi_file_iwrite_all_ = ompi_file_iwrite_all_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IWRITE_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IWRITE_ALL = ompi_file_iwrite_all_f
 #pragma weak mpi_file_iwrite_all = ompi_file_iwrite_all_f
 #pragma weak mpi_file_iwrite_all_ = ompi_file_iwrite_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iwrite_at_all_f.c b/ompi/mpi/fortran/mpif-h/file_iwrite_at_all_f.c
index 743a301af93..209a872b214 100644
--- a/ompi/mpi/fortran/mpif-h/file_iwrite_at_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iwrite_at_all_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IWRITE_AT_ALL = ompi_file_iwrite_at_all_f
 #pragma weak pmpi_file_iwrite_at_all = ompi_file_iwrite_at_all_f
 #pragma weak pmpi_file_iwrite_at_all_ = ompi_file_iwrite_at_all_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IWRITE_AT_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IWRITE_AT_ALL = ompi_file_iwrite_at_all_f
 #pragma weak mpi_file_iwrite_at_all = ompi_file_iwrite_at_all_f
 #pragma weak mpi_file_iwrite_at_all_ = ompi_file_iwrite_at_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iwrite_at_f.c b/ompi/mpi/fortran/mpif-h/file_iwrite_at_f.c
index faab1b45059..b811b142daf 100644
--- a/ompi/mpi/fortran/mpif-h/file_iwrite_at_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iwrite_at_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IWRITE_AT = ompi_file_iwrite_at_f
 #pragma weak pmpi_file_iwrite_at = ompi_file_iwrite_at_f
 #pragma weak pmpi_file_iwrite_at_ = ompi_file_iwrite_at_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IWRITE_AT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IWRITE_AT = ompi_file_iwrite_at_f
 #pragma weak mpi_file_iwrite_at = ompi_file_iwrite_at_f
 #pragma weak mpi_file_iwrite_at_ = ompi_file_iwrite_at_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iwrite_f.c b/ompi/mpi/fortran/mpif-h/file_iwrite_f.c
index b4b87bc4f14..aec345a983e 100644
--- a/ompi/mpi/fortran/mpif-h/file_iwrite_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iwrite_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IWRITE = ompi_file_iwrite_f
 #pragma weak pmpi_file_iwrite = ompi_file_iwrite_f
 #pragma weak pmpi_file_iwrite_ = ompi_file_iwrite_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IWRITE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IWRITE = ompi_file_iwrite_f
 #pragma weak mpi_file_iwrite = ompi_file_iwrite_f
 #pragma weak mpi_file_iwrite_ = ompi_file_iwrite_f
diff --git a/ompi/mpi/fortran/mpif-h/file_iwrite_shared_f.c b/ompi/mpi/fortran/mpif-h/file_iwrite_shared_f.c
index c0ffc386c72..ed0f6f3212c 100644
--- a/ompi/mpi/fortran/mpif-h/file_iwrite_shared_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_iwrite_shared_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_IWRITE_SHARED = ompi_file_iwrite_shared_f
 #pragma weak pmpi_file_iwrite_shared = ompi_file_iwrite_shared_f
 #pragma weak pmpi_file_iwrite_shared_ = ompi_file_iwrite_shared_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_IWRITE_SHARED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_IWRITE_SHARED = ompi_file_iwrite_shared_f
 #pragma weak mpi_file_iwrite_shared = ompi_file_iwrite_shared_f
 #pragma weak mpi_file_iwrite_shared_ = ompi_file_iwrite_shared_f
diff --git a/ompi/mpi/fortran/mpif-h/file_open_f.c b/ompi/mpi/fortran/mpif-h/file_open_f.c
index 8049987dda4..f47d7eb4cea 100644
--- a/ompi/mpi/fortran/mpif-h/file_open_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_open_f.c
@@ -26,7 +26,7 @@
 #include "ompi/file/file.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_OPEN = ompi_file_open_f
 #pragma weak pmpi_file_open = ompi_file_open_f
 #pragma weak pmpi_file_open_ = ompi_file_open_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_OPEN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_OPEN = ompi_file_open_f
 #pragma weak mpi_file_open = ompi_file_open_f
 #pragma weak mpi_file_open_ = ompi_file_open_f
diff --git a/ompi/mpi/fortran/mpif-h/file_preallocate_f.c b/ompi/mpi/fortran/mpif-h/file_preallocate_f.c
index 1f0a596872e..25352ff9f53 100644
--- a/ompi/mpi/fortran/mpif-h/file_preallocate_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_preallocate_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_PREALLOCATE = ompi_file_preallocate_f
 #pragma weak pmpi_file_preallocate = ompi_file_preallocate_f
 #pragma weak pmpi_file_preallocate_ = ompi_file_preallocate_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_PREALLOCATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_PREALLOCATE = ompi_file_preallocate_f
 #pragma weak mpi_file_preallocate = ompi_file_preallocate_f
 #pragma weak mpi_file_preallocate_ = ompi_file_preallocate_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_all_begin_f.c b/ompi/mpi/fortran/mpif-h/file_read_all_begin_f.c
index 1b55844c3b8..d3e9fd9d90e 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_all_begin_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_all_begin_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_ALL_BEGIN = ompi_file_read_all_begin_f
 #pragma weak pmpi_file_read_all_begin = ompi_file_read_all_begin_f
 #pragma weak pmpi_file_read_all_begin_ = ompi_file_read_all_begin_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_ALL_BEGIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_ALL_BEGIN = ompi_file_read_all_begin_f
 #pragma weak mpi_file_read_all_begin = ompi_file_read_all_begin_f
 #pragma weak mpi_file_read_all_begin_ = ompi_file_read_all_begin_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_all_end_f.c b/ompi/mpi/fortran/mpif-h/file_read_all_end_f.c
index 1e9881c8858..e7ea54f23e7 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_all_end_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_all_end_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_ALL_END = ompi_file_read_all_end_f
 #pragma weak pmpi_file_read_all_end = ompi_file_read_all_end_f
 #pragma weak pmpi_file_read_all_end_ = ompi_file_read_all_end_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_ALL_END,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_ALL_END = ompi_file_read_all_end_f
 #pragma weak mpi_file_read_all_end = ompi_file_read_all_end_f
 #pragma weak mpi_file_read_all_end_ = ompi_file_read_all_end_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_all_f.c b/ompi/mpi/fortran/mpif-h/file_read_all_f.c
index b49a7e26bde..81dbacc8222 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_all_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_ALL = ompi_file_read_all_f
 #pragma weak pmpi_file_read_all = ompi_file_read_all_f
 #pragma weak pmpi_file_read_all_ = ompi_file_read_all_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_ALL = ompi_file_read_all_f
 #pragma weak mpi_file_read_all = ompi_file_read_all_f
 #pragma weak mpi_file_read_all_ = ompi_file_read_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_at_all_begin_f.c b/ompi/mpi/fortran/mpif-h/file_read_at_all_begin_f.c
index 1078d57de35..6460ee52c18 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_at_all_begin_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_at_all_begin_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_AT_ALL_BEGIN = ompi_file_read_at_all_begin_f
 #pragma weak pmpi_file_read_at_all_begin = ompi_file_read_at_all_begin_f
 #pragma weak pmpi_file_read_at_all_begin_ = ompi_file_read_at_all_begin_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_AT_ALL_BEGIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_AT_ALL_BEGIN = ompi_file_read_at_all_begin_f
 #pragma weak mpi_file_read_at_all_begin = ompi_file_read_at_all_begin_f
 #pragma weak mpi_file_read_at_all_begin_ = ompi_file_read_at_all_begin_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_at_all_end_f.c b/ompi/mpi/fortran/mpif-h/file_read_at_all_end_f.c
index 3d30c635fc3..7eed1433eee 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_at_all_end_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_at_all_end_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_AT_ALL_END = ompi_file_read_at_all_end_f
 #pragma weak pmpi_file_read_at_all_end = ompi_file_read_at_all_end_f
 #pragma weak pmpi_file_read_at_all_end_ = ompi_file_read_at_all_end_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_AT_ALL_END,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_AT_ALL_END = ompi_file_read_at_all_end_f
 #pragma weak mpi_file_read_at_all_end = ompi_file_read_at_all_end_f
 #pragma weak mpi_file_read_at_all_end_ = ompi_file_read_at_all_end_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_at_all_f.c b/ompi/mpi/fortran/mpif-h/file_read_at_all_f.c
index 2ac4c021a66..79c9570ac01 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_at_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_at_all_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_AT_ALL = ompi_file_read_at_all_f
 #pragma weak pmpi_file_read_at_all = ompi_file_read_at_all_f
 #pragma weak pmpi_file_read_at_all_ = ompi_file_read_at_all_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_AT_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_AT_ALL = ompi_file_read_at_all_f
 #pragma weak mpi_file_read_at_all = ompi_file_read_at_all_f
 #pragma weak mpi_file_read_at_all_ = ompi_file_read_at_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_at_f.c b/ompi/mpi/fortran/mpif-h/file_read_at_f.c
index b48594503be..538d7c2cd13 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_at_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_at_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_AT = ompi_file_read_at_f
 #pragma weak pmpi_file_read_at = ompi_file_read_at_f
 #pragma weak pmpi_file_read_at_ = ompi_file_read_at_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_AT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_AT = ompi_file_read_at_f
 #pragma weak mpi_file_read_at = ompi_file_read_at_f
 #pragma weak mpi_file_read_at_ = ompi_file_read_at_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_f.c b/ompi/mpi/fortran/mpif-h/file_read_f.c
index 97895289be6..80ca792356f 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ = ompi_file_read_f
 #pragma weak pmpi_file_read = ompi_file_read_f
 #pragma weak pmpi_file_read_ = ompi_file_read_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ = ompi_file_read_f
 #pragma weak mpi_file_read = ompi_file_read_f
 #pragma weak mpi_file_read_ = ompi_file_read_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_ordered_begin_f.c b/ompi/mpi/fortran/mpif-h/file_read_ordered_begin_f.c
index 4c294f93980..c0a13a0a1fc 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_ordered_begin_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_ordered_begin_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_ORDERED_BEGIN = ompi_file_read_ordered_begin_f
 #pragma weak pmpi_file_read_ordered_begin = ompi_file_read_ordered_begin_f
 #pragma weak pmpi_file_read_ordered_begin_ = ompi_file_read_ordered_begin_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_ORDERED_BEGIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_ORDERED_BEGIN = ompi_file_read_ordered_begin_f
 #pragma weak mpi_file_read_ordered_begin = ompi_file_read_ordered_begin_f
 #pragma weak mpi_file_read_ordered_begin_ = ompi_file_read_ordered_begin_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_ordered_end_f.c b/ompi/mpi/fortran/mpif-h/file_read_ordered_end_f.c
index 811d6df8b44..4537545ed23 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_ordered_end_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_ordered_end_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_ORDERED_END = ompi_file_read_ordered_end_f
 #pragma weak pmpi_file_read_ordered_end = ompi_file_read_ordered_end_f
 #pragma weak pmpi_file_read_ordered_end_ = ompi_file_read_ordered_end_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_ORDERED_END,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_ORDERED_END = ompi_file_read_ordered_end_f
 #pragma weak mpi_file_read_ordered_end = ompi_file_read_ordered_end_f
 #pragma weak mpi_file_read_ordered_end_ = ompi_file_read_ordered_end_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_ordered_f.c b/ompi/mpi/fortran/mpif-h/file_read_ordered_f.c
index 452380fe293..baa1aa49d87 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_ordered_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_ordered_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_ORDERED = ompi_file_read_ordered_f
 #pragma weak pmpi_file_read_ordered = ompi_file_read_ordered_f
 #pragma weak pmpi_file_read_ordered_ = ompi_file_read_ordered_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_ORDERED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_ORDERED = ompi_file_read_ordered_f
 #pragma weak mpi_file_read_ordered = ompi_file_read_ordered_f
 #pragma weak mpi_file_read_ordered_ = ompi_file_read_ordered_f
diff --git a/ompi/mpi/fortran/mpif-h/file_read_shared_f.c b/ompi/mpi/fortran/mpif-h/file_read_shared_f.c
index 6d945ca60fd..1eed8074235 100644
--- a/ompi/mpi/fortran/mpif-h/file_read_shared_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_read_shared_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_READ_SHARED = ompi_file_read_shared_f
 #pragma weak pmpi_file_read_shared = ompi_file_read_shared_f
 #pragma weak pmpi_file_read_shared_ = ompi_file_read_shared_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_READ_SHARED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_READ_SHARED = ompi_file_read_shared_f
 #pragma weak mpi_file_read_shared = ompi_file_read_shared_f
 #pragma weak mpi_file_read_shared_ = ompi_file_read_shared_f
diff --git a/ompi/mpi/fortran/mpif-h/file_seek_f.c b/ompi/mpi/fortran/mpif-h/file_seek_f.c
index 02bfe39c90a..72dd4a34b23 100644
--- a/ompi/mpi/fortran/mpif-h/file_seek_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_seek_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SEEK = ompi_file_seek_f
 #pragma weak pmpi_file_seek = ompi_file_seek_f
 #pragma weak pmpi_file_seek_ = ompi_file_seek_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SEEK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SEEK = ompi_file_seek_f
 #pragma weak mpi_file_seek = ompi_file_seek_f
 #pragma weak mpi_file_seek_ = ompi_file_seek_f
diff --git a/ompi/mpi/fortran/mpif-h/file_seek_shared_f.c b/ompi/mpi/fortran/mpif-h/file_seek_shared_f.c
index 9189ec6c371..ea2e0c33836 100644
--- a/ompi/mpi/fortran/mpif-h/file_seek_shared_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_seek_shared_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SEEK_SHARED = ompi_file_seek_shared_f
 #pragma weak pmpi_file_seek_shared = ompi_file_seek_shared_f
 #pragma weak pmpi_file_seek_shared_ = ompi_file_seek_shared_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SEEK_SHARED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SEEK_SHARED = ompi_file_seek_shared_f
 #pragma weak mpi_file_seek_shared = ompi_file_seek_shared_f
 #pragma weak mpi_file_seek_shared_ = ompi_file_seek_shared_f
diff --git a/ompi/mpi/fortran/mpif-h/file_set_atomicity_f.c b/ompi/mpi/fortran/mpif-h/file_set_atomicity_f.c
index 0f4549ee112..0821de3f973 100644
--- a/ompi/mpi/fortran/mpif-h/file_set_atomicity_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_set_atomicity_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SET_ATOMICITY = ompi_file_set_atomicity_f
 #pragma weak pmpi_file_set_atomicity = ompi_file_set_atomicity_f
 #pragma weak pmpi_file_set_atomicity_ = ompi_file_set_atomicity_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SET_ATOMICITY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SET_ATOMICITY = ompi_file_set_atomicity_f
 #pragma weak mpi_file_set_atomicity = ompi_file_set_atomicity_f
 #pragma weak mpi_file_set_atomicity_ = ompi_file_set_atomicity_f
diff --git a/ompi/mpi/fortran/mpif-h/file_set_errhandler_f.c b/ompi/mpi/fortran/mpif-h/file_set_errhandler_f.c
index 769378cd1f1..0c6d75a8f90 100644
--- a/ompi/mpi/fortran/mpif-h/file_set_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_set_errhandler_f.c
@@ -25,7 +25,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SET_ERRHANDLER = ompi_file_set_errhandler_f
 #pragma weak pmpi_file_set_errhandler = ompi_file_set_errhandler_f
 #pragma weak pmpi_file_set_errhandler_ = ompi_file_set_errhandler_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SET_ERRHANDLER = ompi_file_set_errhandler_f
 #pragma weak mpi_file_set_errhandler = ompi_file_set_errhandler_f
 #pragma weak mpi_file_set_errhandler_ = ompi_file_set_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/file_set_info_f.c b/ompi/mpi/fortran/mpif-h/file_set_info_f.c
index 5fb03686e89..6e77e64f334 100644
--- a/ompi/mpi/fortran/mpif-h/file_set_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_set_info_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SET_INFO = ompi_file_set_info_f
 #pragma weak pmpi_file_set_info = ompi_file_set_info_f
 #pragma weak pmpi_file_set_info_ = ompi_file_set_info_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SET_INFO = ompi_file_set_info_f
 #pragma weak mpi_file_set_info = ompi_file_set_info_f
 #pragma weak mpi_file_set_info_ = ompi_file_set_info_f
diff --git a/ompi/mpi/fortran/mpif-h/file_set_size_f.c b/ompi/mpi/fortran/mpif-h/file_set_size_f.c
index cdadd67d724..585ee866e41 100644
--- a/ompi/mpi/fortran/mpif-h/file_set_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_set_size_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SET_SIZE = ompi_file_set_size_f
 #pragma weak pmpi_file_set_size = ompi_file_set_size_f
 #pragma weak pmpi_file_set_size_ = ompi_file_set_size_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SET_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SET_SIZE = ompi_file_set_size_f
 #pragma weak mpi_file_set_size = ompi_file_set_size_f
 #pragma weak mpi_file_set_size_ = ompi_file_set_size_f
diff --git a/ompi/mpi/fortran/mpif-h/file_set_view_f.c b/ompi/mpi/fortran/mpif-h/file_set_view_f.c
index 5e301d2d698..cf7eb23915f 100644
--- a/ompi/mpi/fortran/mpif-h/file_set_view_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_set_view_f.c
@@ -26,7 +26,7 @@
 #include "ompi/file/file.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SET_VIEW = ompi_file_set_view_f
 #pragma weak pmpi_file_set_view = ompi_file_set_view_f
 #pragma weak pmpi_file_set_view_ = ompi_file_set_view_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SET_VIEW,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SET_VIEW = ompi_file_set_view_f
 #pragma weak mpi_file_set_view = ompi_file_set_view_f
 #pragma weak mpi_file_set_view_ = ompi_file_set_view_f
diff --git a/ompi/mpi/fortran/mpif-h/file_sync_f.c b/ompi/mpi/fortran/mpif-h/file_sync_f.c
index 2e1d425b48b..639742afdaf 100644
--- a/ompi/mpi/fortran/mpif-h/file_sync_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_sync_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_SYNC = ompi_file_sync_f
 #pragma weak pmpi_file_sync = ompi_file_sync_f
 #pragma weak pmpi_file_sync_ = ompi_file_sync_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_SYNC,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_SYNC = ompi_file_sync_f
 #pragma weak mpi_file_sync = ompi_file_sync_f
 #pragma weak mpi_file_sync_ = ompi_file_sync_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_all_begin_f.c b/ompi/mpi/fortran/mpif-h/file_write_all_begin_f.c
index e91f4624c22..21523dbe233 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_all_begin_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_all_begin_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_ALL_BEGIN = ompi_file_write_all_begin_f
 #pragma weak pmpi_file_write_all_begin = ompi_file_write_all_begin_f
 #pragma weak pmpi_file_write_all_begin_ = ompi_file_write_all_begin_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_ALL_BEGIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_ALL_BEGIN = ompi_file_write_all_begin_f
 #pragma weak mpi_file_write_all_begin = ompi_file_write_all_begin_f
 #pragma weak mpi_file_write_all_begin_ = ompi_file_write_all_begin_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_all_end_f.c b/ompi/mpi/fortran/mpif-h/file_write_all_end_f.c
index af6be08878d..97e798d21df 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_all_end_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_all_end_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_ALL_END = ompi_file_write_all_end_f
 #pragma weak pmpi_file_write_all_end = ompi_file_write_all_end_f
 #pragma weak pmpi_file_write_all_end_ = ompi_file_write_all_end_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_ALL_END,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_ALL_END = ompi_file_write_all_end_f
 #pragma weak mpi_file_write_all_end = ompi_file_write_all_end_f
 #pragma weak mpi_file_write_all_end_ = ompi_file_write_all_end_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_all_f.c b/ompi/mpi/fortran/mpif-h/file_write_all_f.c
index 8245c5e3aa9..df96983d579 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_all_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_ALL = ompi_file_write_all_f
 #pragma weak pmpi_file_write_all = ompi_file_write_all_f
 #pragma weak pmpi_file_write_all_ = ompi_file_write_all_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_ALL = ompi_file_write_all_f
 #pragma weak mpi_file_write_all = ompi_file_write_all_f
 #pragma weak mpi_file_write_all_ = ompi_file_write_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_at_all_begin_f.c b/ompi/mpi/fortran/mpif-h/file_write_at_all_begin_f.c
index 01e825e6967..372eb1ee3a7 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_at_all_begin_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_at_all_begin_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_AT_ALL_BEGIN = ompi_file_write_at_all_begin_f
 #pragma weak pmpi_file_write_at_all_begin = ompi_file_write_at_all_begin_f
 #pragma weak pmpi_file_write_at_all_begin_ = ompi_file_write_at_all_begin_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_AT_ALL_BEGIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_AT_ALL_BEGIN = ompi_file_write_at_all_begin_f
 #pragma weak mpi_file_write_at_all_begin = ompi_file_write_at_all_begin_f
 #pragma weak mpi_file_write_at_all_begin_ = ompi_file_write_at_all_begin_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_at_all_end_f.c b/ompi/mpi/fortran/mpif-h/file_write_at_all_end_f.c
index f27daf9d438..5a5fd3ca331 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_at_all_end_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_at_all_end_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_AT_ALL_END = ompi_file_write_at_all_end_f
 #pragma weak pmpi_file_write_at_all_end = ompi_file_write_at_all_end_f
 #pragma weak pmpi_file_write_at_all_end_ = ompi_file_write_at_all_end_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_AT_ALL_END,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_AT_ALL_END = ompi_file_write_at_all_end_f
 #pragma weak mpi_file_write_at_all_end = ompi_file_write_at_all_end_f
 #pragma weak mpi_file_write_at_all_end_ = ompi_file_write_at_all_end_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_at_all_f.c b/ompi/mpi/fortran/mpif-h/file_write_at_all_f.c
index 575db9e4bc5..550e1ddb952 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_at_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_at_all_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_AT_ALL = ompi_file_write_at_all_f
 #pragma weak pmpi_file_write_at_all = ompi_file_write_at_all_f
 #pragma weak pmpi_file_write_at_all_ = ompi_file_write_at_all_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_AT_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_AT_ALL = ompi_file_write_at_all_f
 #pragma weak mpi_file_write_at_all = ompi_file_write_at_all_f
 #pragma weak mpi_file_write_at_all_ = ompi_file_write_at_all_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_at_f.c b/ompi/mpi/fortran/mpif-h/file_write_at_f.c
index b542139d1ff..9af4ef99db8 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_at_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_at_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_AT = ompi_file_write_at_f
 #pragma weak pmpi_file_write_at = ompi_file_write_at_f
 #pragma weak pmpi_file_write_at_ = ompi_file_write_at_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_AT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_AT = ompi_file_write_at_f
 #pragma weak mpi_file_write_at = ompi_file_write_at_f
 #pragma weak mpi_file_write_at_ = ompi_file_write_at_f
@@ -65,7 +65,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_FILE_WRITE_AT,
                            (fh, offset, buf, count, datatype, status, ierr) )
 #endif
 
-#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_SYMBOLS
+#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_ALIASES
 #define ompi_file_write_at_f pompi_file_write_at_f
 #endif
 #endif
diff --git a/ompi/mpi/fortran/mpif-h/file_write_f.c b/ompi/mpi/fortran/mpif-h/file_write_f.c
index d49c5f50a49..64cf3fa5264 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE = ompi_file_write_f
 #pragma weak pmpi_file_write = ompi_file_write_f
 #pragma weak pmpi_file_write_ = ompi_file_write_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE = ompi_file_write_f
 #pragma weak mpi_file_write = ompi_file_write_f
 #pragma weak mpi_file_write_ = ompi_file_write_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_ordered_begin_f.c b/ompi/mpi/fortran/mpif-h/file_write_ordered_begin_f.c
index 582461a1400..80f6c391058 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_ordered_begin_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_ordered_begin_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_ORDERED_BEGIN = ompi_file_write_ordered_begin_f
 #pragma weak pmpi_file_write_ordered_begin = ompi_file_write_ordered_begin_f
 #pragma weak pmpi_file_write_ordered_begin_ = ompi_file_write_ordered_begin_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_ORDERED_BEGIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_ORDERED_BEGIN = ompi_file_write_ordered_begin_f
 #pragma weak mpi_file_write_ordered_begin = ompi_file_write_ordered_begin_f
 #pragma weak mpi_file_write_ordered_begin_ = ompi_file_write_ordered_begin_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_ordered_end_f.c b/ompi/mpi/fortran/mpif-h/file_write_ordered_end_f.c
index 6126ef037ab..31aefdf5f6d 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_ordered_end_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_ordered_end_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_ORDERED_END = ompi_file_write_ordered_end_f
 #pragma weak pmpi_file_write_ordered_end = ompi_file_write_ordered_end_f
 #pragma weak pmpi_file_write_ordered_end_ = ompi_file_write_ordered_end_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_ORDERED_END,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_ORDERED_END = ompi_file_write_ordered_end_f
 #pragma weak mpi_file_write_ordered_end = ompi_file_write_ordered_end_f
 #pragma weak mpi_file_write_ordered_end_ = ompi_file_write_ordered_end_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_ordered_f.c b/ompi/mpi/fortran/mpif-h/file_write_ordered_f.c
index 293e140d372..253b30bdf97 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_ordered_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_ordered_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_ORDERED = ompi_file_write_ordered_f
 #pragma weak pmpi_file_write_ordered = ompi_file_write_ordered_f
 #pragma weak pmpi_file_write_ordered_ = ompi_file_write_ordered_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_ORDERED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_ORDERED = ompi_file_write_ordered_f
 #pragma weak mpi_file_write_ordered = ompi_file_write_ordered_f
 #pragma weak mpi_file_write_ordered_ = ompi_file_write_ordered_f
diff --git a/ompi/mpi/fortran/mpif-h/file_write_shared_f.c b/ompi/mpi/fortran/mpif-h/file_write_shared_f.c
index 196688a533a..fe8386757ca 100644
--- a/ompi/mpi/fortran/mpif-h/file_write_shared_f.c
+++ b/ompi/mpi/fortran/mpif-h/file_write_shared_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FILE_WRITE_SHARED = ompi_file_write_shared_f
 #pragma weak pmpi_file_write_shared = ompi_file_write_shared_f
 #pragma weak pmpi_file_write_shared_ = ompi_file_write_shared_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FILE_WRITE_SHARED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FILE_WRITE_SHARED = ompi_file_write_shared_f
 #pragma weak mpi_file_write_shared = ompi_file_write_shared_f
 #pragma weak mpi_file_write_shared_ = ompi_file_write_shared_f
diff --git a/ompi/mpi/fortran/mpif-h/finalize_f.c b/ompi/mpi/fortran/mpif-h/finalize_f.c
index c0dc45fbd8a..04969548e5c 100644
--- a/ompi/mpi/fortran/mpif-h/finalize_f.c
+++ b/ompi/mpi/fortran/mpif-h/finalize_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FINALIZE = ompi_finalize_f
 #pragma weak pmpi_finalize = ompi_finalize_f
 #pragma weak pmpi_finalize_ = ompi_finalize_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FINALIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FINALIZE = ompi_finalize_f
 #pragma weak mpi_finalize = ompi_finalize_f
 #pragma weak mpi_finalize_ = ompi_finalize_f
diff --git a/ompi/mpi/fortran/mpif-h/finalized_f.c b/ompi/mpi/fortran/mpif-h/finalized_f.c
index 8095e719a53..c810030824b 100644
--- a/ompi/mpi/fortran/mpif-h/finalized_f.c
+++ b/ompi/mpi/fortran/mpif-h/finalized_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FINALIZED = ompi_finalized_f
 #pragma weak pmpi_finalized = ompi_finalized_f
 #pragma weak pmpi_finalized_ = ompi_finalized_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FINALIZED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FINALIZED = ompi_finalized_f
 #pragma weak mpi_finalized = ompi_finalized_f
 #pragma weak mpi_finalized_ = ompi_finalized_f
diff --git a/ompi/mpi/fortran/mpif-h/free_mem_f.c b/ompi/mpi/fortran/mpif-h/free_mem_f.c
index 5a9e8507b2f..c6ecc163c5d 100644
--- a/ompi/mpi/fortran/mpif-h/free_mem_f.c
+++ b/ompi/mpi/fortran/mpif-h/free_mem_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_FREE_MEM = ompi_free_mem_f
 #pragma weak pmpi_free_mem = ompi_free_mem_f
 #pragma weak pmpi_free_mem_ = ompi_free_mem_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_FREE_MEM,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_FREE_MEM = ompi_free_mem_f
 #pragma weak mpi_free_mem = ompi_free_mem_f
 #pragma weak mpi_free_mem_ = ompi_free_mem_f
diff --git a/ompi/mpi/fortran/mpif-h/gather_f.c b/ompi/mpi/fortran/mpif-h/gather_f.c
index 0019d17d1c9..a13bcb40707 100644
--- a/ompi/mpi/fortran/mpif-h/gather_f.c
+++ b/ompi/mpi/fortran/mpif-h/gather_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GATHER = ompi_gather_f
 #pragma weak pmpi_gather = ompi_gather_f
 #pragma weak pmpi_gather_ = ompi_gather_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GATHER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GATHER = ompi_gather_f
 #pragma weak mpi_gather = ompi_gather_f
 #pragma weak mpi_gather_ = ompi_gather_f
diff --git a/ompi/mpi/fortran/mpif-h/gather_init_f.c b/ompi/mpi/fortran/mpif-h/gather_init_f.c
index 19e7197cc87..fa0067a2af5 100644
--- a/ompi/mpi/fortran/mpif-h/gather_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/gather_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GATHER_INIT = ompi_gather_init_f
 #pragma weak pmpi_gather_init = ompi_gather_init_f
 #pragma weak pmpi_gather_init_ = ompi_gather_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GATHER_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GATHER_INIT = ompi_gather_init_f
 #pragma weak mpi_gather_init = ompi_gather_init_f
 #pragma weak mpi_gather_init_ = ompi_gather_init_f
diff --git a/ompi/mpi/fortran/mpif-h/gatherv_f.c b/ompi/mpi/fortran/mpif-h/gatherv_f.c
index ef235ebe686..6b2a864d464 100644
--- a/ompi/mpi/fortran/mpif-h/gatherv_f.c
+++ b/ompi/mpi/fortran/mpif-h/gatherv_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GATHERV = ompi_gatherv_f
 #pragma weak pmpi_gatherv = ompi_gatherv_f
 #pragma weak pmpi_gatherv_ = ompi_gatherv_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GATHERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GATHERV = ompi_gatherv_f
 #pragma weak mpi_gatherv = ompi_gatherv_f
 #pragma weak mpi_gatherv_ = ompi_gatherv_f
diff --git a/ompi/mpi/fortran/mpif-h/gatherv_init_f.c b/ompi/mpi/fortran/mpif-h/gatherv_init_f.c
index a87a5c9ddcc..c780564c398 100644
--- a/ompi/mpi/fortran/mpif-h/gatherv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/gatherv_init_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GATHERV_INIT = ompi_gatherv_init_f
 #pragma weak pmpi_gatherv_init = ompi_gatherv_init_f
 #pragma weak pmpi_gatherv_init_ = ompi_gatherv_init_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GATHERV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GATHERV_INIT = ompi_gatherv_init_f
 #pragma weak mpi_gatherv_init = ompi_gatherv_init_f
 #pragma weak mpi_gatherv_init_ = ompi_gatherv_init_f
@@ -77,7 +79,7 @@ void ompi_gatherv_init_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendtype,
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Info c_info;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(recvcounts);
     OMPI_ARRAY_NAME_DECL(displs);
 
@@ -104,12 +106,11 @@ void ompi_gatherv_init_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendtype,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (recvcounts != OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(displs);
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
      } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(displs);
diff --git a/ompi/mpi/fortran/mpif-h/get_accumulate_f.c b/ompi/mpi/fortran/mpif-h/get_accumulate_f.c
index ff15d4aa11f..4661f85f757 100644
--- a/ompi/mpi/fortran/mpif-h/get_accumulate_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_accumulate_f.c
@@ -29,7 +29,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_ACCUMULATE = ompi_get_accumulate_f
 #pragma weak pmpi_get_accumulate = ompi_get_accumulate_f
 #pragma weak pmpi_get_accumulate_ = ompi_get_accumulate_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_ACCUMULATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_ACCUMULATE = ompi_get_accumulate_f
 #pragma weak mpi_get_accumulate = ompi_get_accumulate_f
 #pragma weak mpi_get_accumulate_ = ompi_get_accumulate_f
diff --git a/ompi/mpi/fortran/mpif-h/get_address_f.c b/ompi/mpi/fortran/mpif-h/get_address_f.c
index 4c19d61dfdc..7f90e847290 100644
--- a/ompi/mpi/fortran/mpif-h/get_address_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_address_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_ADDRESS = ompi_get_address_f
 #pragma weak pmpi_get_address = ompi_get_address_f
 #pragma weak pmpi_get_address_ = ompi_get_address_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_ADDRESS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_ADDRESS = ompi_get_address_f
 #pragma weak mpi_get_address = ompi_get_address_f
 #pragma weak mpi_get_address_ = ompi_get_address_f
diff --git a/ompi/mpi/fortran/mpif-h/get_count_f.c b/ompi/mpi/fortran/mpif-h/get_count_f.c
index 1c9a7de47e4..98c744ad5b3 100644
--- a/ompi/mpi/fortran/mpif-h/get_count_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_count_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_COUNT = ompi_get_count_f
 #pragma weak pmpi_get_count = ompi_get_count_f
 #pragma weak pmpi_get_count_ = ompi_get_count_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_COUNT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_COUNT = ompi_get_count_f
 #pragma weak mpi_get_count = ompi_get_count_f
 #pragma weak mpi_get_count_ = ompi_get_count_f
diff --git a/ompi/mpi/fortran/mpif-h/get_elements_f.c b/ompi/mpi/fortran/mpif-h/get_elements_f.c
index 7e3b1e0676a..e12430da7ec 100644
--- a/ompi/mpi/fortran/mpif-h/get_elements_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_elements_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_ELEMENTS = ompi_get_elements_f
 #pragma weak pmpi_get_elements = ompi_get_elements_f
 #pragma weak pmpi_get_elements_ = ompi_get_elements_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_ELEMENTS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_ELEMENTS = ompi_get_elements_f
 #pragma weak mpi_get_elements = ompi_get_elements_f
 #pragma weak mpi_get_elements_ = ompi_get_elements_f
diff --git a/ompi/mpi/fortran/mpif-h/get_elements_x_f.c b/ompi/mpi/fortran/mpif-h/get_elements_x_f.c
index 044b2f200d5..b0ea4725321 100644
--- a/ompi/mpi/fortran/mpif-h/get_elements_x_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_elements_x_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_ELEMENTS_X = ompi_get_elements_x_f
 #pragma weak pmpi_get_elements_x = ompi_get_elements_x_f
 #pragma weak pmpi_get_elements_x_ = ompi_get_elements_x_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_ELEMENTS_X,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_ELEMENTS_X = ompi_get_elements_x_f
 #pragma weak mpi_get_elements_x = ompi_get_elements_x_f
 #pragma weak mpi_get_elements_x_ = ompi_get_elements_x_f
diff --git a/ompi/mpi/fortran/mpif-h/get_f.c b/ompi/mpi/fortran/mpif-h/get_f.c
index 0442adb346a..43b0cdbaa5b 100644
--- a/ompi/mpi/fortran/mpif-h/get_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_f.c
@@ -26,7 +26,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET = ompi_get_f
 #pragma weak pmpi_get = ompi_get_f
 #pragma weak pmpi_get_ = ompi_get_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET = ompi_get_f
 #pragma weak mpi_get = ompi_get_f
 #pragma weak mpi_get_ = ompi_get_f
diff --git a/ompi/mpi/fortran/mpif-h/get_hw_resource_info_f.c b/ompi/mpi/fortran/mpif-h/get_hw_resource_info_f.c
index ca18bb45fbc..c1f79b068cb 100644
--- a/ompi/mpi/fortran/mpif-h/get_hw_resource_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_hw_resource_info_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_HW_RESOURCE_INFO = ompi_get_hw_resource_info_f
 #pragma weak pmpi_get_hw_resource_info = ompi_get_hw_resource_info_f
 #pragma weak pmpi_get_hw_resource_info_ = ompi_get_hw_resource_info_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_HW_RESOURCE_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_HW_RESOURCE_INFO = ompi_get_hw_resource_info_f
 #pragma weak mpi_get_hw_resource_info = ompi_get_hw_resource_info_f
 #pragma weak mpi_get_hw_resource_info_ = ompi_get_hw_resource_info_f
diff --git a/ompi/mpi/fortran/mpif-h/get_library_version_f.c b/ompi/mpi/fortran/mpif-h/get_library_version_f.c
index 429eee154d4..67b57bb44d0 100644
--- a/ompi/mpi/fortran/mpif-h/get_library_version_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_library_version_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_LIBRARY_VERSION = ompi_get_library_version_f
 #pragma weak pmpi_get_library_version = ompi_get_library_version_f
 #pragma weak pmpi_get_library_version_ = ompi_get_library_version_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_LIBRARY_VERSION,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_LIBRARY_VERSION = ompi_get_library_version_f
 #pragma weak mpi_get_library_version = ompi_get_library_version_f
 #pragma weak mpi_get_library_version_ = ompi_get_library_version_f
diff --git a/ompi/mpi/fortran/mpif-h/get_processor_name_f.c b/ompi/mpi/fortran/mpif-h/get_processor_name_f.c
index c3c0b133735..e932389a5b0 100644
--- a/ompi/mpi/fortran/mpif-h/get_processor_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_processor_name_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_PROCESSOR_NAME = ompi_get_processor_name_f
 #pragma weak pmpi_get_processor_name = ompi_get_processor_name_f
 #pragma weak pmpi_get_processor_name_ = ompi_get_processor_name_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_PROCESSOR_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_PROCESSOR_NAME = ompi_get_processor_name_f
 #pragma weak mpi_get_processor_name = ompi_get_processor_name_f
 #pragma weak mpi_get_processor_name_ = ompi_get_processor_name_f
diff --git a/ompi/mpi/fortran/mpif-h/get_version_f.c b/ompi/mpi/fortran/mpif-h/get_version_f.c
index 07b4f76f442..cba14b4c590 100644
--- a/ompi/mpi/fortran/mpif-h/get_version_f.c
+++ b/ompi/mpi/fortran/mpif-h/get_version_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GET_VERSION = ompi_get_version_f
 #pragma weak pmpi_get_version = ompi_get_version_f
 #pragma weak pmpi_get_version_ = ompi_get_version_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GET_VERSION,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GET_VERSION = ompi_get_version_f
 #pragma weak mpi_get_version = ompi_get_version_f
 #pragma weak mpi_get_version_ = ompi_get_version_f
diff --git a/ompi/mpi/fortran/mpif-h/graph_create_f.c b/ompi/mpi/fortran/mpif-h/graph_create_f.c
index 70f487b0e6b..ac1c32f276b 100644
--- a/ompi/mpi/fortran/mpif-h/graph_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/graph_create_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GRAPH_CREATE = ompi_graph_create_f
 #pragma weak pmpi_graph_create = ompi_graph_create_f
 #pragma weak pmpi_graph_create_ = ompi_graph_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GRAPH_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GRAPH_CREATE = ompi_graph_create_f
 #pragma weak mpi_graph_create = ompi_graph_create_f
 #pragma weak mpi_graph_create_ = ompi_graph_create_f
diff --git a/ompi/mpi/fortran/mpif-h/graph_get_f.c b/ompi/mpi/fortran/mpif-h/graph_get_f.c
index afea6ac5b15..7095fdc13df 100644
--- a/ompi/mpi/fortran/mpif-h/graph_get_f.c
+++ b/ompi/mpi/fortran/mpif-h/graph_get_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GRAPH_GET = ompi_graph_get_f
 #pragma weak pmpi_graph_get = ompi_graph_get_f
 #pragma weak pmpi_graph_get_ = ompi_graph_get_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GRAPH_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GRAPH_GET = ompi_graph_get_f
 #pragma weak mpi_graph_get = ompi_graph_get_f
 #pragma weak mpi_graph_get_ = ompi_graph_get_f
diff --git a/ompi/mpi/fortran/mpif-h/graph_map_f.c b/ompi/mpi/fortran/mpif-h/graph_map_f.c
index 8905820bdd0..309dfd8692f 100644
--- a/ompi/mpi/fortran/mpif-h/graph_map_f.c
+++ b/ompi/mpi/fortran/mpif-h/graph_map_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GRAPH_MAP = ompi_graph_map_f
 #pragma weak pmpi_graph_map = ompi_graph_map_f
 #pragma weak pmpi_graph_map_ = ompi_graph_map_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GRAPH_MAP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GRAPH_MAP = ompi_graph_map_f
 #pragma weak mpi_graph_map = ompi_graph_map_f
 #pragma weak mpi_graph_map_ = ompi_graph_map_f
diff --git a/ompi/mpi/fortran/mpif-h/graph_neighbors_count_f.c b/ompi/mpi/fortran/mpif-h/graph_neighbors_count_f.c
index d23292a8128..1c5e4681fa2 100644
--- a/ompi/mpi/fortran/mpif-h/graph_neighbors_count_f.c
+++ b/ompi/mpi/fortran/mpif-h/graph_neighbors_count_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GRAPH_NEIGHBORS_COUNT = ompi_graph_neighbors_count_f
 #pragma weak pmpi_graph_neighbors_count = ompi_graph_neighbors_count_f
 #pragma weak pmpi_graph_neighbors_count_ = ompi_graph_neighbors_count_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GRAPH_NEIGHBORS_COUNT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GRAPH_NEIGHBORS_COUNT = ompi_graph_neighbors_count_f
 #pragma weak mpi_graph_neighbors_count = ompi_graph_neighbors_count_f
 #pragma weak mpi_graph_neighbors_count_ = ompi_graph_neighbors_count_f
diff --git a/ompi/mpi/fortran/mpif-h/graph_neighbors_f.c b/ompi/mpi/fortran/mpif-h/graph_neighbors_f.c
index e89b9733a85..d3ee7ec7680 100644
--- a/ompi/mpi/fortran/mpif-h/graph_neighbors_f.c
+++ b/ompi/mpi/fortran/mpif-h/graph_neighbors_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GRAPH_NEIGHBORS = ompi_graph_neighbors_f
 #pragma weak pmpi_graph_neighbors = ompi_graph_neighbors_f
 #pragma weak pmpi_graph_neighbors_ = ompi_graph_neighbors_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GRAPH_NEIGHBORS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GRAPH_NEIGHBORS = ompi_graph_neighbors_f
 #pragma weak mpi_graph_neighbors = ompi_graph_neighbors_f
 #pragma weak mpi_graph_neighbors_ = ompi_graph_neighbors_f
diff --git a/ompi/mpi/fortran/mpif-h/graphdims_get_f.c b/ompi/mpi/fortran/mpif-h/graphdims_get_f.c
index f0231612102..639497bc0fe 100644
--- a/ompi/mpi/fortran/mpif-h/graphdims_get_f.c
+++ b/ompi/mpi/fortran/mpif-h/graphdims_get_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GRAPHDIMS_GET = ompi_graphdims_get_f
 #pragma weak pmpi_graphdims_get = ompi_graphdims_get_f
 #pragma weak pmpi_graphdims_get_ = ompi_graphdims_get_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GRAPHDIMS_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GRAPHDIMS_GET = ompi_graphdims_get_f
 #pragma weak mpi_graphdims_get = ompi_graphdims_get_f
 #pragma weak mpi_graphdims_get_ = ompi_graphdims_get_f
diff --git a/ompi/mpi/fortran/mpif-h/grequest_complete_f.c b/ompi/mpi/fortran/mpif-h/grequest_complete_f.c
index 075c2e459f6..27dd1721615 100644
--- a/ompi/mpi/fortran/mpif-h/grequest_complete_f.c
+++ b/ompi/mpi/fortran/mpif-h/grequest_complete_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GREQUEST_COMPLETE = ompi_grequest_complete_f
 #pragma weak pmpi_grequest_complete = ompi_grequest_complete_f
 #pragma weak pmpi_grequest_complete_ = ompi_grequest_complete_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GREQUEST_COMPLETE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GREQUEST_COMPLETE = ompi_grequest_complete_f
 #pragma weak mpi_grequest_complete = ompi_grequest_complete_f
 #pragma weak mpi_grequest_complete_ = ompi_grequest_complete_f
diff --git a/ompi/mpi/fortran/mpif-h/grequest_start_f.c b/ompi/mpi/fortran/mpif-h/grequest_start_f.c
index 9e12b1c40a1..e301b1d88af 100644
--- a/ompi/mpi/fortran/mpif-h/grequest_start_f.c
+++ b/ompi/mpi/fortran/mpif-h/grequest_start_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GREQUEST_START = ompi_grequest_start_f
 #pragma weak pmpi_grequest_start = ompi_grequest_start_f
 #pragma weak pmpi_grequest_start_ = ompi_grequest_start_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GREQUEST_START,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GREQUEST_START = ompi_grequest_start_f
 #pragma weak mpi_grequest_start = ompi_grequest_start_f
 #pragma weak mpi_grequest_start_ = ompi_grequest_start_f
diff --git a/ompi/mpi/fortran/mpif-h/group_compare_f.c b/ompi/mpi/fortran/mpif-h/group_compare_f.c
index bc80330bcc6..d45748aae66 100644
--- a/ompi/mpi/fortran/mpif-h/group_compare_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_compare_f.c
@@ -26,7 +26,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_COMPARE = ompi_group_compare_f
 #pragma weak pmpi_group_compare = ompi_group_compare_f
 #pragma weak pmpi_group_compare_ = ompi_group_compare_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_COMPARE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_COMPARE = ompi_group_compare_f
 #pragma weak mpi_group_compare = ompi_group_compare_f
 #pragma weak mpi_group_compare_ = ompi_group_compare_f
@@ -56,7 +56,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_COMPARE,
 #pragma weak MPI_Group_compare_f08 = ompi_group_compare_f
 #endif
 
-#if ! OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_SYMBOLS
+#if ! OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_ALIASES
 OMPI_GENERATE_F77_BINDINGS (MPI_GROUP_COMPARE,
                            mpi_group_compare,
                            mpi_group_compare_,
@@ -69,7 +69,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_GROUP_COMPARE,
 
 
 
-#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_SYMBOLS
+#if OMPI_BUILD_MPI_PROFILING && ! OPAL_HAVE_WEAK_ALIASES
 #define ompi_group_compare_f pompi_group_compare_f
 #endif
 
diff --git a/ompi/mpi/fortran/mpif-h/group_difference_f.c b/ompi/mpi/fortran/mpif-h/group_difference_f.c
index ea8356cdb4d..a1b426e094f 100644
--- a/ompi/mpi/fortran/mpif-h/group_difference_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_difference_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_DIFFERENCE = ompi_group_difference_f
 #pragma weak pmpi_group_difference = ompi_group_difference_f
 #pragma weak pmpi_group_difference_ = ompi_group_difference_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_DIFFERENCE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_DIFFERENCE = ompi_group_difference_f
 #pragma weak mpi_group_difference = ompi_group_difference_f
 #pragma weak mpi_group_difference_ = ompi_group_difference_f
diff --git a/ompi/mpi/fortran/mpif-h/group_excl_f.c b/ompi/mpi/fortran/mpif-h/group_excl_f.c
index e739d5e746f..6c68c0ae5da 100644
--- a/ompi/mpi/fortran/mpif-h/group_excl_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_excl_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_EXCL = ompi_group_excl_f
 #pragma weak pmpi_group_excl = ompi_group_excl_f
 #pragma weak pmpi_group_excl_ = ompi_group_excl_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_EXCL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_EXCL = ompi_group_excl_f
 #pragma weak mpi_group_excl = ompi_group_excl_f
 #pragma weak mpi_group_excl_ = ompi_group_excl_f
diff --git a/ompi/mpi/fortran/mpif-h/group_free_f.c b/ompi/mpi/fortran/mpif-h/group_free_f.c
index 3875b8cf0cd..6e8476891bf 100644
--- a/ompi/mpi/fortran/mpif-h/group_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_free_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_FREE = ompi_group_free_f
 #pragma weak pmpi_group_free = ompi_group_free_f
 #pragma weak pmpi_group_free_ = ompi_group_free_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_FREE = ompi_group_free_f
 #pragma weak mpi_group_free = ompi_group_free_f
 #pragma weak mpi_group_free_ = ompi_group_free_f
diff --git a/ompi/mpi/fortran/mpif-h/group_from_session_pset_f.c b/ompi/mpi/fortran/mpif-h/group_from_session_pset_f.c
index 061c2f3a42d..3b014776c08 100644
--- a/ompi/mpi/fortran/mpif-h/group_from_session_pset_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_from_session_pset_f.c
@@ -33,7 +33,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_FROM_SESSION_PSET = ompi_group_from_session_pset_f
 #pragma weak pmpi_group_from_session_pset = ompi_group_from_session_pset_f
 #pragma weak pmpi_group_from_session_pset_ = ompi_group_from_session_pset_f
@@ -52,7 +52,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_FROM_SESSION_PSET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_FROM_SESSION_PSET = ompi_group_from_session_pset_f
 #pragma weak mpi_group_from_session_pset = ompi_group_from_session_pset_f
 #pragma weak mpi_group_from_session_pset_ = ompi_group_from_session_pset_f
diff --git a/ompi/mpi/fortran/mpif-h/group_incl_f.c b/ompi/mpi/fortran/mpif-h/group_incl_f.c
index 0bc4b3edcd7..05d579eb4ea 100644
--- a/ompi/mpi/fortran/mpif-h/group_incl_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_incl_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_INCL = ompi_group_incl_f
 #pragma weak pmpi_group_incl = ompi_group_incl_f
 #pragma weak pmpi_group_incl_ = ompi_group_incl_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_INCL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_INCL = ompi_group_incl_f
 #pragma weak mpi_group_incl = ompi_group_incl_f
 #pragma weak mpi_group_incl_ = ompi_group_incl_f
diff --git a/ompi/mpi/fortran/mpif-h/group_intersection_f.c b/ompi/mpi/fortran/mpif-h/group_intersection_f.c
index 7cbca9de649..50cc4f0428b 100644
--- a/ompi/mpi/fortran/mpif-h/group_intersection_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_intersection_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_INTERSECTION = ompi_group_intersection_f
 #pragma weak pmpi_group_intersection = ompi_group_intersection_f
 #pragma weak pmpi_group_intersection_ = ompi_group_intersection_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_INTERSECTION,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_INTERSECTION = ompi_group_intersection_f
 #pragma weak mpi_group_intersection = ompi_group_intersection_f
 #pragma weak mpi_group_intersection_ = ompi_group_intersection_f
diff --git a/ompi/mpi/fortran/mpif-h/group_range_excl_f.c b/ompi/mpi/fortran/mpif-h/group_range_excl_f.c
index 8e138d5d29a..9ed1ba4cea1 100644
--- a/ompi/mpi/fortran/mpif-h/group_range_excl_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_range_excl_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_RANGE_EXCL = ompi_group_range_excl_f
 #pragma weak pmpi_group_range_excl = ompi_group_range_excl_f
 #pragma weak pmpi_group_range_excl_ = ompi_group_range_excl_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_RANGE_EXCL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_RANGE_EXCL = ompi_group_range_excl_f
 #pragma weak mpi_group_range_excl = ompi_group_range_excl_f
 #pragma weak mpi_group_range_excl_ = ompi_group_range_excl_f
diff --git a/ompi/mpi/fortran/mpif-h/group_range_incl_f.c b/ompi/mpi/fortran/mpif-h/group_range_incl_f.c
index d3059aff69f..944a75b546a 100644
--- a/ompi/mpi/fortran/mpif-h/group_range_incl_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_range_incl_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_RANGE_INCL = ompi_group_range_incl_f
 #pragma weak pmpi_group_range_incl = ompi_group_range_incl_f
 #pragma weak pmpi_group_range_incl_ = ompi_group_range_incl_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_RANGE_INCL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_RANGE_INCL = ompi_group_range_incl_f
 #pragma weak mpi_group_range_incl = ompi_group_range_incl_f
 #pragma weak mpi_group_range_incl_ = ompi_group_range_incl_f
diff --git a/ompi/mpi/fortran/mpif-h/group_rank_f.c b/ompi/mpi/fortran/mpif-h/group_rank_f.c
index fac60432b60..64826b70a06 100644
--- a/ompi/mpi/fortran/mpif-h/group_rank_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_rank_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_RANK = ompi_group_rank_f
 #pragma weak pmpi_group_rank = ompi_group_rank_f
 #pragma weak pmpi_group_rank_ = ompi_group_rank_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_RANK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_RANK = ompi_group_rank_f
 #pragma weak mpi_group_rank = ompi_group_rank_f
 #pragma weak mpi_group_rank_ = ompi_group_rank_f
diff --git a/ompi/mpi/fortran/mpif-h/group_size_f.c b/ompi/mpi/fortran/mpif-h/group_size_f.c
index 6e25c35d1f0..5a30e65c75f 100644
--- a/ompi/mpi/fortran/mpif-h/group_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_size_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_SIZE = ompi_group_size_f
 #pragma weak pmpi_group_size = ompi_group_size_f
 #pragma weak pmpi_group_size_ = ompi_group_size_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_SIZE = ompi_group_size_f
 #pragma weak mpi_group_size = ompi_group_size_f
 #pragma weak mpi_group_size_ = ompi_group_size_f
diff --git a/ompi/mpi/fortran/mpif-h/group_translate_ranks_f.c b/ompi/mpi/fortran/mpif-h/group_translate_ranks_f.c
index 37b13cb9af3..dce6108cd18 100644
--- a/ompi/mpi/fortran/mpif-h/group_translate_ranks_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_translate_ranks_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_TRANSLATE_RANKS = ompi_group_translate_ranks_f
 #pragma weak pmpi_group_translate_ranks = ompi_group_translate_ranks_f
 #pragma weak pmpi_group_translate_ranks_ = ompi_group_translate_ranks_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_TRANSLATE_RANKS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_TRANSLATE_RANKS = ompi_group_translate_ranks_f
 #pragma weak mpi_group_translate_ranks = ompi_group_translate_ranks_f
 #pragma weak mpi_group_translate_ranks_ = ompi_group_translate_ranks_f
diff --git a/ompi/mpi/fortran/mpif-h/group_union_f.c b/ompi/mpi/fortran/mpif-h/group_union_f.c
index df6a326cd33..4a41db39c8c 100644
--- a/ompi/mpi/fortran/mpif-h/group_union_f.c
+++ b/ompi/mpi/fortran/mpif-h/group_union_f.c
@@ -25,7 +25,7 @@
 #include "ompi/group/group.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_GROUP_UNION = ompi_group_union_f
 #pragma weak pmpi_group_union = ompi_group_union_f
 #pragma weak pmpi_group_union_ = ompi_group_union_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_GROUP_UNION,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_GROUP_UNION = ompi_group_union_f
 #pragma weak mpi_group_union = ompi_group_union_f
 #pragma weak mpi_group_union_ = ompi_group_union_f
diff --git a/ompi/mpi/fortran/mpif-h/iallgather_f.c b/ompi/mpi/fortran/mpif-h/iallgather_f.c
index 6b61cc55522..4b5413dd164 100644
--- a/ompi/mpi/fortran/mpif-h/iallgather_f.c
+++ b/ompi/mpi/fortran/mpif-h/iallgather_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IALLGATHER = ompi_iallgather_f
 #pragma weak pmpi_iallgather = ompi_iallgather_f
 #pragma weak pmpi_iallgather_ = ompi_iallgather_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IALLGATHER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IALLGATHER = ompi_iallgather_f
 #pragma weak mpi_iallgather = ompi_iallgather_f
 #pragma weak mpi_iallgather_ = ompi_iallgather_f
diff --git a/ompi/mpi/fortran/mpif-h/iallgatherv_f.c b/ompi/mpi/fortran/mpif-h/iallgatherv_f.c
index 37926247905..f0499c5556d 100644
--- a/ompi/mpi/fortran/mpif-h/iallgatherv_f.c
+++ b/ompi/mpi/fortran/mpif-h/iallgatherv_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IALLGATHERV = ompi_iallgatherv_f
 #pragma weak pmpi_iallgatherv = ompi_iallgatherv_f
 #pragma weak pmpi_iallgatherv_ = ompi_iallgatherv_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IALLGATHERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IALLGATHERV = ompi_iallgatherv_f
 #pragma weak mpi_iallgatherv = ompi_iallgatherv_f
 #pragma weak mpi_iallgatherv_ = ompi_iallgatherv_f
@@ -76,7 +78,7 @@ void ompi_iallgatherv_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendtype,
     MPI_Comm c_comm;
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
-    int size, idx = 0, ierr_c;
+    int size, ierr_c;
     OMPI_ARRAY_NAME_DECL(recvcounts);
     OMPI_ARRAY_NAME_DECL(displs);
 
@@ -107,11 +109,10 @@ void ompi_iallgatherv_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendtype,
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(displs);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (recvcounts != OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(displs);
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/iallreduce_f.c b/ompi/mpi/fortran/mpif-h/iallreduce_f.c
index 3bcb92967d5..17ef07e1316 100644
--- a/ompi/mpi/fortran/mpif-h/iallreduce_f.c
+++ b/ompi/mpi/fortran/mpif-h/iallreduce_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IALLREDUCE = ompi_iallreduce_f
 #pragma weak pmpi_iallreduce = ompi_iallreduce_f
 #pragma weak pmpi_iallreduce_ = ompi_iallreduce_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IALLREDUCE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IALLREDUCE = ompi_iallreduce_f
 #pragma weak mpi_iallreduce = ompi_iallreduce_f
 #pragma weak mpi_iallreduce_ = ompi_iallreduce_f
diff --git a/ompi/mpi/fortran/mpif-h/ialltoall_f.c b/ompi/mpi/fortran/mpif-h/ialltoall_f.c
index 27b8ca4bd64..d3e30b7ce3b 100644
--- a/ompi/mpi/fortran/mpif-h/ialltoall_f.c
+++ b/ompi/mpi/fortran/mpif-h/ialltoall_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IALLTOALL = ompi_ialltoall_f
 #pragma weak pmpi_ialltoall = ompi_ialltoall_f
 #pragma weak pmpi_ialltoall_ = ompi_ialltoall_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IALLTOALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IALLTOALL = ompi_ialltoall_f
 #pragma weak mpi_ialltoall = ompi_ialltoall_f
 #pragma weak mpi_ialltoall_ = ompi_ialltoall_f
diff --git a/ompi/mpi/fortran/mpif-h/ialltoallv_f.c b/ompi/mpi/fortran/mpif-h/ialltoallv_f.c
index b519a3c82cb..fdd5a0ea5f1 100644
--- a/ompi/mpi/fortran/mpif-h/ialltoallv_f.c
+++ b/ompi/mpi/fortran/mpif-h/ialltoallv_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IALLTOALLV = ompi_ialltoallv_f
 #pragma weak pmpi_ialltoallv = ompi_ialltoallv_f
 #pragma weak pmpi_ialltoallv_ = ompi_ialltoallv_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IALLTOALLV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IALLTOALLV = ompi_ialltoallv_f
 #pragma weak mpi_ialltoallv = ompi_ialltoallv_f
 #pragma weak mpi_ialltoallv_ = ompi_ialltoallv_f
@@ -76,7 +78,7 @@ void ompi_ialltoallv_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *sdispls,
     MPI_Comm c_comm;
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(sdispls);
     OMPI_ARRAY_NAME_DECL(recvcounts);
@@ -113,13 +115,12 @@ void ompi_ialltoallv_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *sdispls,
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(rdispls);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sdispls);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(rdispls);
+        if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sdispls));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(rdispls));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/ialltoallw_f.c b/ompi/mpi/fortran/mpif-h/ialltoallw_f.c
index 1c5dd1400f3..d0592876bf4 100644
--- a/ompi/mpi/fortran/mpif-h/ialltoallw_f.c
+++ b/ompi/mpi/fortran/mpif-h/ialltoallw_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -27,7 +29,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IALLTOALLW = ompi_ialltoallw_f
 #pragma weak pmpi_ialltoallw = ompi_ialltoallw_f
 #pragma weak pmpi_ialltoallw_ = ompi_ialltoallw_f
@@ -46,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IALLTOALLW,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IALLTOALLW = ompi_ialltoallw_f
 #pragma weak mpi_ialltoallw = ompi_ialltoallw_f
 #pragma weak mpi_ialltoallw_ = ompi_ialltoallw_f
@@ -78,7 +80,7 @@ void ompi_ialltoallw_f(char *sendbuf, MPI_Fint *sendcounts,
     MPI_Comm c_comm;
     MPI_Datatype *c_sendtypes = NULL, *c_recvtypes;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(sdispls);
     OMPI_ARRAY_NAME_DECL(recvcounts);
@@ -128,17 +130,16 @@ void ompi_ialltoallw_f(char *sendbuf, MPI_Fint *sendcounts,
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(rdispls);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
+        if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
         }
-        if (sdispls != OMPI_ARRAY_NAME_CONVERT(sdispls)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sdispls);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(rdispls);
+        if ((void *)sdispls != (void *)OMPI_ARRAY_NAME_CONVERT(sdispls)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sdispls));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(rdispls));
         }
-        nb_request->data.release_arrays[idx++] = c_recvtypes;
-        nb_request->data.release_arrays[idx++] = c_sendtypes;
-        nb_request->data.release_arrays[idx]   = NULL;
+        ompi_coll_base_append_array_to_release(c_request, c_recvtypes);
+        ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
+        ompi_coll_base_add_release_arrays_cb(c_request);
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/ibarrier_f.c b/ompi/mpi/fortran/mpif-h/ibarrier_f.c
index a649ddeffe5..00a608a6ee8 100644
--- a/ompi/mpi/fortran/mpif-h/ibarrier_f.c
+++ b/ompi/mpi/fortran/mpif-h/ibarrier_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IBARRIER = ompi_ibarrier_f
 #pragma weak pmpi_ibarrier = ompi_ibarrier_f
 #pragma weak pmpi_ibarrier_ = ompi_ibarrier_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IBARRIER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IBARRIER = ompi_ibarrier_f
 #pragma weak mpi_ibarrier = ompi_ibarrier_f
 #pragma weak mpi_ibarrier_ = ompi_ibarrier_f
diff --git a/ompi/mpi/fortran/mpif-h/ibcast_f.c b/ompi/mpi/fortran/mpif-h/ibcast_f.c
index 497b54c339c..0f7b5c7c35e 100644
--- a/ompi/mpi/fortran/mpif-h/ibcast_f.c
+++ b/ompi/mpi/fortran/mpif-h/ibcast_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IBCAST = ompi_ibcast_f
 #pragma weak pmpi_ibcast = ompi_ibcast_f
 #pragma weak pmpi_ibcast_ = ompi_ibcast_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IBCAST,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IBCAST = ompi_ibcast_f
 #pragma weak mpi_ibcast = ompi_ibcast_f
 #pragma weak mpi_ibcast_ = ompi_ibcast_f
diff --git a/ompi/mpi/fortran/mpif-h/ibsend_f.c b/ompi/mpi/fortran/mpif-h/ibsend_f.c
index 088febdbcbb..960ddaa43f1 100644
--- a/ompi/mpi/fortran/mpif-h/ibsend_f.c
+++ b/ompi/mpi/fortran/mpif-h/ibsend_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IBSEND = ompi_ibsend_f
 #pragma weak pmpi_ibsend = ompi_ibsend_f
 #pragma weak pmpi_ibsend_ = ompi_ibsend_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IBSEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IBSEND = ompi_ibsend_f
 #pragma weak mpi_ibsend = ompi_ibsend_f
 #pragma weak mpi_ibsend_ = ompi_ibsend_f
diff --git a/ompi/mpi/fortran/mpif-h/iexscan_f.c b/ompi/mpi/fortran/mpif-h/iexscan_f.c
index cd41416244f..53d36e29c9d 100644
--- a/ompi/mpi/fortran/mpif-h/iexscan_f.c
+++ b/ompi/mpi/fortran/mpif-h/iexscan_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IEXSCAN = ompi_iexscan_f
 #pragma weak pmpi_iexscan = ompi_iexscan_f
 #pragma weak pmpi_iexscan_ = ompi_iexscan_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IEXSCAN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IEXSCAN = ompi_iexscan_f
 #pragma weak mpi_iexscan = ompi_iexscan_f
 #pragma weak mpi_iexscan_ = ompi_iexscan_f
diff --git a/ompi/mpi/fortran/mpif-h/igather_f.c b/ompi/mpi/fortran/mpif-h/igather_f.c
index f234581d0c3..cd04bbfdd18 100644
--- a/ompi/mpi/fortran/mpif-h/igather_f.c
+++ b/ompi/mpi/fortran/mpif-h/igather_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IGATHER = ompi_igather_f
 #pragma weak pmpi_igather = ompi_igather_f
 #pragma weak pmpi_igather_ = ompi_igather_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IGATHER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IGATHER = ompi_igather_f
 #pragma weak mpi_igather = ompi_igather_f
 #pragma weak mpi_igather_ = ompi_igather_f
diff --git a/ompi/mpi/fortran/mpif-h/igatherv_f.c b/ompi/mpi/fortran/mpif-h/igatherv_f.c
index 8af9e33b914..9eaee8a727e 100644
--- a/ompi/mpi/fortran/mpif-h/igatherv_f.c
+++ b/ompi/mpi/fortran/mpif-h/igatherv_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IGATHERV = ompi_igatherv_f
 #pragma weak pmpi_igatherv = ompi_igatherv_f
 #pragma weak pmpi_igatherv_ = ompi_igatherv_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IGATHERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IGATHERV = ompi_igatherv_f
 #pragma weak mpi_igatherv = ompi_igatherv_f
 #pragma weak mpi_igatherv_ = ompi_igatherv_f
@@ -76,7 +78,7 @@ void ompi_igatherv_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendtype,
     MPI_Comm c_comm;
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(recvcounts);
     OMPI_ARRAY_NAME_DECL(displs);
 
@@ -106,11 +108,10 @@ void ompi_igatherv_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *sendtype,
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(displs);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (recvcounts != OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(displs);
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/improbe_f.c b/ompi/mpi/fortran/mpif-h/improbe_f.c
index af5fa2b01fe..7e83c98097d 100644
--- a/ompi/mpi/fortran/mpif-h/improbe_f.c
+++ b/ompi/mpi/fortran/mpif-h/improbe_f.c
@@ -29,7 +29,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IMPROBE = ompi_improbe_f
 #pragma weak pmpi_improbe = ompi_improbe_f
 #pragma weak pmpi_improbe_ = ompi_improbe_f
@@ -49,7 +49,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IMPROBE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IMPROBE = ompi_improbe_f
 #pragma weak mpi_improbe = ompi_improbe_f
 #pragma weak mpi_improbe_ = ompi_improbe_f
diff --git a/ompi/mpi/fortran/mpif-h/imrecv_f.c b/ompi/mpi/fortran/mpif-h/imrecv_f.c
index 2f706d941c1..3ee9144577b 100644
--- a/ompi/mpi/fortran/mpif-h/imrecv_f.c
+++ b/ompi/mpi/fortran/mpif-h/imrecv_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IMRECV = ompi_imrecv_f
 #pragma weak pmpi_imrecv = ompi_imrecv_f
 #pragma weak pmpi_imrecv_ = ompi_imrecv_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IMRECV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IMRECV = ompi_imrecv_f
 #pragma weak mpi_imrecv = ompi_imrecv_f
 #pragma weak mpi_imrecv_ = ompi_imrecv_f
diff --git a/ompi/mpi/fortran/mpif-h/ineighbor_allgather_f.c b/ompi/mpi/fortran/mpif-h/ineighbor_allgather_f.c
index ecd0221187a..ef1efaf75ea 100644
--- a/ompi/mpi/fortran/mpif-h/ineighbor_allgather_f.c
+++ b/ompi/mpi/fortran/mpif-h/ineighbor_allgather_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INEIGHBOR_ALLGATHER = ompi_ineighbor_allgather_f
 #pragma weak pmpi_ineighbor_allgather = ompi_ineighbor_allgather_f
 #pragma weak pmpi_ineighbor_allgather_ = ompi_ineighbor_allgather_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INEIGHBOR_ALLGATHER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INEIGHBOR_ALLGATHER = ompi_ineighbor_allgather_f
 #pragma weak mpi_ineighbor_allgather = ompi_ineighbor_allgather_f
 #pragma weak mpi_ineighbor_allgather_ = ompi_ineighbor_allgather_f
diff --git a/ompi/mpi/fortran/mpif-h/ineighbor_allgatherv_f.c b/ompi/mpi/fortran/mpif-h/ineighbor_allgatherv_f.c
index 390e3dd2a74..8f2d9c77f4d 100644
--- a/ompi/mpi/fortran/mpif-h/ineighbor_allgatherv_f.c
+++ b/ompi/mpi/fortran/mpif-h/ineighbor_allgatherv_f.c
@@ -15,6 +15,8 @@
  *                         reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -29,7 +31,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INEIGHBOR_ALLGATHERV = ompi_ineighbor_allgatherv_f
 #pragma weak pmpi_ineighbor_allgatherv = ompi_ineighbor_allgatherv_f
 #pragma weak pmpi_ineighbor_allgatherv_ = ompi_ineighbor_allgatherv_f
@@ -48,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INEIGHBOR_ALLGATHERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INEIGHBOR_ALLGATHERV = ompi_ineighbor_allgatherv_f
 #pragma weak mpi_ineighbor_allgatherv = ompi_ineighbor_allgatherv_f
 #pragma weak mpi_ineighbor_allgatherv_ = ompi_ineighbor_allgatherv_f
@@ -79,7 +81,7 @@ void ompi_ineighbor_allgatherv_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *s
     MPI_Comm c_comm;
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
-    int size, idx = 0, ierr_c;
+    int size, ierr_c;
     OMPI_ARRAY_NAME_DECL(recvcounts);
     OMPI_ARRAY_NAME_DECL(displs);
 
@@ -106,12 +108,11 @@ void ompi_ineighbor_allgatherv_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fint *s
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(ierr_c);
     if (MPI_SUCCESS == ierr_c) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (recvcounts != OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(displs);
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
     } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(displs);
diff --git a/ompi/mpi/fortran/mpif-h/ineighbor_alltoall_f.c b/ompi/mpi/fortran/mpif-h/ineighbor_alltoall_f.c
index b565f1b74ed..2e43f38966b 100644
--- a/ompi/mpi/fortran/mpif-h/ineighbor_alltoall_f.c
+++ b/ompi/mpi/fortran/mpif-h/ineighbor_alltoall_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INEIGHBOR_ALLTOALL = ompi_ineighbor_alltoall_f
 #pragma weak pmpi_ineighbor_alltoall = ompi_ineighbor_alltoall_f
 #pragma weak pmpi_ineighbor_alltoall_ = ompi_ineighbor_alltoall_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INEIGHBOR_ALLTOALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INEIGHBOR_ALLTOALL = ompi_ineighbor_alltoall_f
 #pragma weak mpi_ineighbor_alltoall = ompi_ineighbor_alltoall_f
 #pragma weak mpi_ineighbor_alltoall_ = ompi_ineighbor_alltoall_f
diff --git a/ompi/mpi/fortran/mpif-h/ineighbor_alltoallv_f.c b/ompi/mpi/fortran/mpif-h/ineighbor_alltoallv_f.c
index c7b9901cadf..cc9602733f5 100644
--- a/ompi/mpi/fortran/mpif-h/ineighbor_alltoallv_f.c
+++ b/ompi/mpi/fortran/mpif-h/ineighbor_alltoallv_f.c
@@ -14,7 +14,8 @@
  * Copyright (c) 2013      Los Alamos National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2025-2026 Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,10 +27,11 @@
 
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 #include "ompi/mpi/fortran/base/constants.h"
+#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INEIGHBOR_ALLTOALLV = ompi_ineighbor_alltoallv_f
 #pragma weak pmpi_ineighbor_alltoallv = ompi_ineighbor_alltoallv_f
 #pragma weak pmpi_ineighbor_alltoallv_ = ompi_ineighbor_alltoallv_f
@@ -48,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INEIGHBOR_ALLTOALLV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INEIGHBOR_ALLTOALLV = ompi_ineighbor_alltoallv_f
 #pragma weak mpi_ineighbor_alltoallv = ompi_ineighbor_alltoallv_f
 #pragma weak mpi_ineighbor_alltoallv_ = ompi_ineighbor_alltoallv_f
@@ -79,7 +81,7 @@ void ompi_ineighbor_alltoallv_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *s
     MPI_Comm c_comm;
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int indegree, outdegree, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(sdispls);
     OMPI_ARRAY_NAME_DECL(recvcounts);
@@ -89,11 +91,16 @@ void ompi_ineighbor_alltoallv_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *s
     c_sendtype = PMPI_Type_f2c(*sendtype);
     c_recvtype = PMPI_Type_f2c(*recvtype);
 
-    PMPI_Comm_size(c_comm, &size);
-    OMPI_ARRAY_FINT_2_INT(sendcounts, size);
-    OMPI_ARRAY_FINT_2_INT(sdispls, size);
-    OMPI_ARRAY_FINT_2_INT(recvcounts, size);
-    OMPI_ARRAY_FINT_2_INT(rdispls, size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        return;
+    }
+
+    OMPI_ARRAY_FINT_2_INT(sendcounts, outdegree);
+    OMPI_ARRAY_FINT_2_INT(sdispls, outdegree);
+    OMPI_ARRAY_FINT_2_INT(recvcounts, indegree);
+    OMPI_ARRAY_FINT_2_INT(rdispls, indegree);
 
     sendbuf = (char *) OMPI_F2C_IN_PLACE(sendbuf);
     sendbuf = (char *) OMPI_F2C_BOTTOM(sendbuf);
@@ -116,11 +123,12 @@ void ompi_ineighbor_alltoallv_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *s
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(rdispls);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-        nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sdispls);
-        nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-        nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(rdispls);
-        nb_request->data.release_arrays[idx]   = NULL;
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sdispls));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(rdispls));
+            ompi_coll_base_add_release_arrays_cb(c_request);
+        }
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/ineighbor_alltoallw_f.c b/ompi/mpi/fortran/mpif-h/ineighbor_alltoallw_f.c
index 680d6a9d94a..f84617907cd 100644
--- a/ompi/mpi/fortran/mpif-h/ineighbor_alltoallw_f.c
+++ b/ompi/mpi/fortran/mpif-h/ineighbor_alltoallw_f.c
@@ -15,6 +15,8 @@
  *                         reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -27,9 +29,10 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 #include "ompi/mpi/fortran/base/constants.h"
 #include "ompi/mca/coll/base/coll_base_util.h"
+#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INEIGHBOR_ALLTOALLW = ompi_ineighbor_alltoallw_f
 #pragma weak pmpi_ineighbor_alltoallw = ompi_ineighbor_alltoallw_f
 #pragma weak pmpi_ineighbor_alltoallw_ = ompi_ineighbor_alltoallw_f
@@ -48,7 +51,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INEIGHBOR_ALLTOALLW,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INEIGHBOR_ALLTOALLW = ompi_ineighbor_alltoallw_f
 #pragma weak mpi_ineighbor_alltoallw = ompi_ineighbor_alltoallw_f
 #pragma weak mpi_ineighbor_alltoallw_ = ompi_ineighbor_alltoallw_f
@@ -80,23 +83,31 @@ void ompi_ineighbor_alltoallw_f(char *sendbuf, MPI_Fint *sendcounts,
     MPI_Comm c_comm;
     MPI_Datatype *c_sendtypes, *c_recvtypes;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int indegree, outdegree, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(recvcounts);
 
     c_comm = PMPI_Comm_f2c(*comm);
-    PMPI_Comm_size(c_comm, &size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        return;
+    }
 
-    c_sendtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
-    c_recvtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+    c_sendtypes = (MPI_Datatype *) malloc(outdegree * sizeof(MPI_Datatype));
+    c_recvtypes = (MPI_Datatype *) malloc(indegree * sizeof(MPI_Datatype));
 
-    OMPI_ARRAY_FINT_2_INT(sendcounts, size);
-    OMPI_ARRAY_FINT_2_INT(recvcounts, size);
+    OMPI_ARRAY_FINT_2_INT(sendcounts, outdegree);
+    OMPI_ARRAY_FINT_2_INT(recvcounts, indegree);
+
+    while (outdegree > 0) {
+        c_sendtypes[outdegree - 1] = PMPI_Type_f2c(sendtypes[outdegree - 1]);
+        --outdegree;
+    }
 
-    while (size > 0) {
-        c_sendtypes[size - 1] = PMPI_Type_f2c(sendtypes[size - 1]);
-        c_recvtypes[size - 1] = PMPI_Type_f2c(recvtypes[size - 1]);
-        --size;
+    while (indegree > 0) {
+        c_recvtypes[indegree - 1] = PMPI_Type_f2c(recvtypes[indegree - 1]);
+        --indegree;
     }
 
     /* Ineighbor_alltoallw does not support MPI_IN_PLACE */
@@ -120,11 +131,12 @@ void ompi_ineighbor_alltoallw_f(char *sendbuf, MPI_Fint *sendcounts,
         free(c_sendtypes);
         free(c_recvtypes);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-        nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-        nb_request->data.release_arrays[idx++] = c_sendtypes;
-        nb_request->data.release_arrays[idx++] = c_recvtypes;
-        nb_request->data.release_arrays[idx]   = NULL;
+        if((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+        }
+        ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
+        ompi_coll_base_append_array_to_release(c_request, c_recvtypes);
+        ompi_coll_base_add_release_arrays_cb(c_request);
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/info_create_env_f.c b/ompi/mpi/fortran/mpif-h/info_create_env_f.c
index e138d73a28e..434aa13e0ac 100644
--- a/ompi/mpi/fortran/mpif-h/info_create_env_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_create_env_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_CREATE_ENV = ompi_info_create_env_f
 #pragma weak pmpi_info_create_env = ompi_info_create_env_f
 #pragma weak pmpi_info_create_env_ = ompi_info_create_env_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_CREATE_ENV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_CREATE_ENV = ompi_info_create_env_f
 #pragma weak mpi_info_create_env = ompi_info_create_env_f
 #pragma weak mpi_info_create_env_ = ompi_info_create_env_f
diff --git a/ompi/mpi/fortran/mpif-h/info_create_f.c b/ompi/mpi/fortran/mpif-h/info_create_f.c
index 3c9dc287bd8..0c7bc6ec0a0 100644
--- a/ompi/mpi/fortran/mpif-h/info_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_create_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_CREATE = ompi_info_create_f
 #pragma weak pmpi_info_create = ompi_info_create_f
 #pragma weak pmpi_info_create_ = ompi_info_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_CREATE = ompi_info_create_f
 #pragma weak mpi_info_create = ompi_info_create_f
 #pragma weak mpi_info_create_ = ompi_info_create_f
diff --git a/ompi/mpi/fortran/mpif-h/info_delete_f.c b/ompi/mpi/fortran/mpif-h/info_delete_f.c
index bebd0fdf010..d5e1f418d01 100644
--- a/ompi/mpi/fortran/mpif-h/info_delete_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_delete_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_DELETE = ompi_info_delete_f
 #pragma weak pmpi_info_delete = ompi_info_delete_f
 #pragma weak pmpi_info_delete_ = ompi_info_delete_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_DELETE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_DELETE = ompi_info_delete_f
 #pragma weak mpi_info_delete = ompi_info_delete_f
 #pragma weak mpi_info_delete_ = ompi_info_delete_f
diff --git a/ompi/mpi/fortran/mpif-h/info_dup_f.c b/ompi/mpi/fortran/mpif-h/info_dup_f.c
index 304746c88ac..f9711d58a55 100644
--- a/ompi/mpi/fortran/mpif-h/info_dup_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_dup_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_DUP = ompi_info_dup_f
 #pragma weak pmpi_info_dup = ompi_info_dup_f
 #pragma weak pmpi_info_dup_ = ompi_info_dup_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_DUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_DUP = ompi_info_dup_f
 #pragma weak mpi_info_dup = ompi_info_dup_f
 #pragma weak mpi_info_dup_ = ompi_info_dup_f
diff --git a/ompi/mpi/fortran/mpif-h/info_free_f.c b/ompi/mpi/fortran/mpif-h/info_free_f.c
index ad769602f6e..fbc59435d69 100644
--- a/ompi/mpi/fortran/mpif-h/info_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_FREE = ompi_info_free_f
 #pragma weak pmpi_info_free = ompi_info_free_f
 #pragma weak pmpi_info_free_ = ompi_info_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_FREE = ompi_info_free_f
 #pragma weak mpi_info_free = ompi_info_free_f
 #pragma weak mpi_info_free_ = ompi_info_free_f
diff --git a/ompi/mpi/fortran/mpif-h/info_get_f.c b/ompi/mpi/fortran/mpif-h/info_get_f.c
index d9d6b4ac859..978f4de02da 100644
--- a/ompi/mpi/fortran/mpif-h/info_get_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_get_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_GET = ompi_info_get_f
 #pragma weak pmpi_info_get = ompi_info_get_f
 #pragma weak pmpi_info_get_ = ompi_info_get_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_GET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_GET = ompi_info_get_f
 #pragma weak mpi_info_get = ompi_info_get_f
 #pragma weak mpi_info_get_ = ompi_info_get_f
diff --git a/ompi/mpi/fortran/mpif-h/info_get_nkeys_f.c b/ompi/mpi/fortran/mpif-h/info_get_nkeys_f.c
index 7cbcffea2c4..728ae2b30c3 100644
--- a/ompi/mpi/fortran/mpif-h/info_get_nkeys_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_get_nkeys_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_GET_NKEYS = ompi_info_get_nkeys_f
 #pragma weak pmpi_info_get_nkeys = ompi_info_get_nkeys_f
 #pragma weak pmpi_info_get_nkeys_ = ompi_info_get_nkeys_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_GET_NKEYS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_GET_NKEYS = ompi_info_get_nkeys_f
 #pragma weak mpi_info_get_nkeys = ompi_info_get_nkeys_f
 #pragma weak mpi_info_get_nkeys_ = ompi_info_get_nkeys_f
diff --git a/ompi/mpi/fortran/mpif-h/info_get_nthkey_f.c b/ompi/mpi/fortran/mpif-h/info_get_nthkey_f.c
index db5223ae2d4..47b4fe8182f 100644
--- a/ompi/mpi/fortran/mpif-h/info_get_nthkey_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_get_nthkey_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_GET_NTHKEY = ompi_info_get_nthkey_f
 #pragma weak pmpi_info_get_nthkey = ompi_info_get_nthkey_f
 #pragma weak pmpi_info_get_nthkey_ = ompi_info_get_nthkey_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_GET_NTHKEY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_GET_NTHKEY = ompi_info_get_nthkey_f
 #pragma weak mpi_info_get_nthkey = ompi_info_get_nthkey_f
 #pragma weak mpi_info_get_nthkey_ = ompi_info_get_nthkey_f
diff --git a/ompi/mpi/fortran/mpif-h/info_get_string_f.c b/ompi/mpi/fortran/mpif-h/info_get_string_f.c
index 76919ba3d85..06248e8358a 100644
--- a/ompi/mpi/fortran/mpif-h/info_get_string_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_get_string_f.c
@@ -28,7 +28,7 @@
 #include "ompi/info/info.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_GET_STRING = ompi_info_get_string_f
 #pragma weak pmpi_info_get_string = ompi_info_get_string_f
 #pragma weak pmpi_info_get_string_ = ompi_info_get_string_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_GET_STRING,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_GET_STRING = ompi_info_get_string_f
 #pragma weak mpi_info_get_string = ompi_info_get_string_f
 #pragma weak mpi_info_get_string_ = ompi_info_get_string_f
diff --git a/ompi/mpi/fortran/mpif-h/info_get_valuelen_f.c b/ompi/mpi/fortran/mpif-h/info_get_valuelen_f.c
index 82d6985df71..3823f9e43ba 100644
--- a/ompi/mpi/fortran/mpif-h/info_get_valuelen_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_get_valuelen_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_GET_VALUELEN = ompi_info_get_valuelen_f
 #pragma weak pmpi_info_get_valuelen = ompi_info_get_valuelen_f
 #pragma weak pmpi_info_get_valuelen_ = ompi_info_get_valuelen_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_GET_VALUELEN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_GET_VALUELEN = ompi_info_get_valuelen_f
 #pragma weak mpi_info_get_valuelen = ompi_info_get_valuelen_f
 #pragma weak mpi_info_get_valuelen_ = ompi_info_get_valuelen_f
diff --git a/ompi/mpi/fortran/mpif-h/info_set_f.c b/ompi/mpi/fortran/mpif-h/info_set_f.c
index 374c2d37b0a..7e7d2837510 100644
--- a/ompi/mpi/fortran/mpif-h/info_set_f.c
+++ b/ompi/mpi/fortran/mpif-h/info_set_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INFO_SET = ompi_info_set_f
 #pragma weak pmpi_info_set = ompi_info_set_f
 #pragma weak pmpi_info_set_ = ompi_info_set_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INFO_SET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INFO_SET = ompi_info_set_f
 #pragma weak mpi_info_set = ompi_info_set_f
 #pragma weak mpi_info_set_ = ompi_info_set_f
diff --git a/ompi/mpi/fortran/mpif-h/init_f.c b/ompi/mpi/fortran/mpif-h/init_f.c
index 8ed309f6827..5ade78926b2 100644
--- a/ompi/mpi/fortran/mpif-h/init_f.c
+++ b/ompi/mpi/fortran/mpif-h/init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INIT = ompi_init_f
 #pragma weak pmpi_init = ompi_init_f
 #pragma weak pmpi_init_ = ompi_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INIT = ompi_init_f
 #pragma weak mpi_init = ompi_init_f
 #pragma weak mpi_init_ = ompi_init_f
diff --git a/ompi/mpi/fortran/mpif-h/init_thread_f.c b/ompi/mpi/fortran/mpif-h/init_thread_f.c
index 2f6acbb44de..7aae025cb2b 100644
--- a/ompi/mpi/fortran/mpif-h/init_thread_f.c
+++ b/ompi/mpi/fortran/mpif-h/init_thread_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INIT_THREAD = ompi_init_thread_f
 #pragma weak pmpi_init_thread = ompi_init_thread_f
 #pragma weak pmpi_init_thread_ = ompi_init_thread_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INIT_THREAD,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INIT_THREAD = ompi_init_thread_f
 #pragma weak mpi_init_thread = ompi_init_thread_f
 #pragma weak mpi_init_thread_ = ompi_init_thread_f
diff --git a/ompi/mpi/fortran/mpif-h/initialized_f.c b/ompi/mpi/fortran/mpif-h/initialized_f.c
index 4489e91b6c2..707377aa5d7 100644
--- a/ompi/mpi/fortran/mpif-h/initialized_f.c
+++ b/ompi/mpi/fortran/mpif-h/initialized_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INITIALIZED = ompi_initialized_f
 #pragma weak pmpi_initialized = ompi_initialized_f
 #pragma weak pmpi_initialized_ = ompi_initialized_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INITIALIZED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INITIALIZED = ompi_initialized_f
 #pragma weak mpi_initialized = ompi_initialized_f
 #pragma weak mpi_initialized_ = ompi_initialized_f
diff --git a/ompi/mpi/fortran/mpif-h/intercomm_create_f.c b/ompi/mpi/fortran/mpif-h/intercomm_create_f.c
index 79cddd8ba50..38f54f8dd66 100644
--- a/ompi/mpi/fortran/mpif-h/intercomm_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/intercomm_create_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INTERCOMM_CREATE = ompi_intercomm_create_f
 #pragma weak pmpi_intercomm_create = ompi_intercomm_create_f
 #pragma weak pmpi_intercomm_create_ = ompi_intercomm_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INTERCOMM_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INTERCOMM_CREATE = ompi_intercomm_create_f
 #pragma weak mpi_intercomm_create = ompi_intercomm_create_f
 #pragma weak mpi_intercomm_create_ = ompi_intercomm_create_f
diff --git a/ompi/mpi/fortran/mpif-h/intercomm_create_from_groups_f.c b/ompi/mpi/fortran/mpif-h/intercomm_create_from_groups_f.c
index 489ec241a3a..f596593f22d 100644
--- a/ompi/mpi/fortran/mpif-h/intercomm_create_from_groups_f.c
+++ b/ompi/mpi/fortran/mpif-h/intercomm_create_from_groups_f.c
@@ -34,7 +34,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INTERCOMM_CREATE_FROM_GROUPS = ompi_intercomm_create_from_groups_f
 #pragma weak pmpi_intercomm_create_from_groups = ompi_intercomm_create_from_groups_f
 #pragma weak pmpi_intercomm_create_from_groups_ = ompi_intercomm_create_from_groups_f
@@ -57,7 +57,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INTERCOMM_CREATE_FROM_GROUPS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INTERCOMM_CREATE_FROM_GROUPS = ompi_intercomm_create_from_groups_f
 #pragma weak mpi_intercomm_create_from_groups = ompi_intercomm_create_from_groups_f
 #pragma weak mpi_intercomm_create_from_groups_ = ompi_intercomm_create_from_groups_f
diff --git a/ompi/mpi/fortran/mpif-h/intercomm_merge_f.c b/ompi/mpi/fortran/mpif-h/intercomm_merge_f.c
index 865350280e1..2e74d1af2b4 100644
--- a/ompi/mpi/fortran/mpif-h/intercomm_merge_f.c
+++ b/ompi/mpi/fortran/mpif-h/intercomm_merge_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_INTERCOMM_MERGE = ompi_intercomm_merge_f
 #pragma weak pmpi_intercomm_merge = ompi_intercomm_merge_f
 #pragma weak pmpi_intercomm_merge_ = ompi_intercomm_merge_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_INTERCOMM_MERGE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_INTERCOMM_MERGE = ompi_intercomm_merge_f
 #pragma weak mpi_intercomm_merge = ompi_intercomm_merge_f
 #pragma weak mpi_intercomm_merge_ = ompi_intercomm_merge_f
diff --git a/ompi/mpi/fortran/mpif-h/iprobe_f.c b/ompi/mpi/fortran/mpif-h/iprobe_f.c
index 4b9f76a3dc4..4406f698231 100644
--- a/ompi/mpi/fortran/mpif-h/iprobe_f.c
+++ b/ompi/mpi/fortran/mpif-h/iprobe_f.c
@@ -28,7 +28,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IPROBE = ompi_iprobe_f
 #pragma weak pmpi_iprobe = ompi_iprobe_f
 #pragma weak pmpi_iprobe_ = ompi_iprobe_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IPROBE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IPROBE = ompi_iprobe_f
 #pragma weak mpi_iprobe = ompi_iprobe_f
 #pragma weak mpi_iprobe_ = ompi_iprobe_f
diff --git a/ompi/mpi/fortran/mpif-h/irecv_f.c b/ompi/mpi/fortran/mpif-h/irecv_f.c
index 5703f226d95..c28cc55faa4 100644
--- a/ompi/mpi/fortran/mpif-h/irecv_f.c
+++ b/ompi/mpi/fortran/mpif-h/irecv_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IRECV = ompi_irecv_f
 #pragma weak pmpi_irecv = ompi_irecv_f
 #pragma weak pmpi_irecv_ = ompi_irecv_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IRECV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IRECV = ompi_irecv_f
 #pragma weak mpi_irecv = ompi_irecv_f
 #pragma weak mpi_irecv_ = ompi_irecv_f
diff --git a/ompi/mpi/fortran/mpif-h/ireduce_f.c b/ompi/mpi/fortran/mpif-h/ireduce_f.c
index 17ee5a3aebd..ed506f01219 100644
--- a/ompi/mpi/fortran/mpif-h/ireduce_f.c
+++ b/ompi/mpi/fortran/mpif-h/ireduce_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IREDUCE = ompi_ireduce_f
 #pragma weak pmpi_ireduce = ompi_ireduce_f
 #pragma weak pmpi_ireduce_ = ompi_ireduce_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IREDUCE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IREDUCE = ompi_ireduce_f
 #pragma weak mpi_ireduce = ompi_ireduce_f
 #pragma weak mpi_ireduce_ = ompi_ireduce_f
diff --git a/ompi/mpi/fortran/mpif-h/ireduce_scatter_block_f.c b/ompi/mpi/fortran/mpif-h/ireduce_scatter_block_f.c
index 89e51fd1102..4ad419b5f5a 100644
--- a/ompi/mpi/fortran/mpif-h/ireduce_scatter_block_f.c
+++ b/ompi/mpi/fortran/mpif-h/ireduce_scatter_block_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IREDUCE_SCATTER_BLOCK = ompi_ireduce_scatter_block_f
 #pragma weak pmpi_ireduce_scatter_block = ompi_ireduce_scatter_block_f
 #pragma weak pmpi_ireduce_scatter_block_ = ompi_ireduce_scatter_block_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IREDUCE_SCATTER_BLOCK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IREDUCE_SCATTER_BLOCK = ompi_ireduce_scatter_block_f
 #pragma weak mpi_ireduce_scatter_block = ompi_ireduce_scatter_block_f
 #pragma weak mpi_ireduce_scatter_block_ = ompi_ireduce_scatter_block_f
diff --git a/ompi/mpi/fortran/mpif-h/ireduce_scatter_f.c b/ompi/mpi/fortran/mpif-h/ireduce_scatter_f.c
index d09a397cac6..51d3ebce2ab 100644
--- a/ompi/mpi/fortran/mpif-h/ireduce_scatter_f.c
+++ b/ompi/mpi/fortran/mpif-h/ireduce_scatter_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IREDUCE_SCATTER = ompi_ireduce_scatter_f
 #pragma weak pmpi_ireduce_scatter = ompi_ireduce_scatter_f
 #pragma weak pmpi_ireduce_scatter_ = ompi_ireduce_scatter_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IREDUCE_SCATTER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IREDUCE_SCATTER = ompi_ireduce_scatter_f
 #pragma weak mpi_ireduce_scatter = ompi_ireduce_scatter_f
 #pragma weak mpi_ireduce_scatter_ = ompi_ireduce_scatter_f
@@ -100,8 +102,9 @@ void ompi_ireduce_scatter_f(char *sendbuf, char *recvbuf,
     if ( REQUEST_COMPLETE(c_request)) {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        nb_request->data.release_arrays[0] = recvcounts;
-        nb_request->data.release_arrays[1] = NULL;
+        if((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, recvcounts);
+            ompi_coll_base_add_release_arrays_cb(c_request);
+        }
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/irsend_f.c b/ompi/mpi/fortran/mpif-h/irsend_f.c
index d4fe6a12bf6..4912f0eb5f6 100644
--- a/ompi/mpi/fortran/mpif-h/irsend_f.c
+++ b/ompi/mpi/fortran/mpif-h/irsend_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IRSEND = ompi_irsend_f
 #pragma weak pmpi_irsend = ompi_irsend_f
 #pragma weak pmpi_irsend_ = ompi_irsend_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IRSEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IRSEND = ompi_irsend_f
 #pragma weak mpi_irsend = ompi_irsend_f
 #pragma weak mpi_irsend_ = ompi_irsend_f
diff --git a/ompi/mpi/fortran/mpif-h/is_thread_main_f.c b/ompi/mpi/fortran/mpif-h/is_thread_main_f.c
index b78c4bfd0ba..ec85469a96a 100644
--- a/ompi/mpi/fortran/mpif-h/is_thread_main_f.c
+++ b/ompi/mpi/fortran/mpif-h/is_thread_main_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_IS_THREAD_MAIN = ompi_is_thread_main_f
 #pragma weak pmpi_is_thread_main = ompi_is_thread_main_f
 #pragma weak pmpi_is_thread_main_ = ompi_is_thread_main_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_IS_THREAD_MAIN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_IS_THREAD_MAIN = ompi_is_thread_main_f
 #pragma weak mpi_is_thread_main = ompi_is_thread_main_f
 #pragma weak mpi_is_thread_main_ = ompi_is_thread_main_f
diff --git a/ompi/mpi/fortran/mpif-h/iscan_f.c b/ompi/mpi/fortran/mpif-h/iscan_f.c
index 0b1271d1a2e..9bf1bc8af28 100644
--- a/ompi/mpi/fortran/mpif-h/iscan_f.c
+++ b/ompi/mpi/fortran/mpif-h/iscan_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ISCAN = ompi_iscan_f
 #pragma weak pmpi_iscan = ompi_iscan_f
 #pragma weak pmpi_iscan_ = ompi_iscan_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ISCAN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ISCAN = ompi_iscan_f
 #pragma weak mpi_iscan = ompi_iscan_f
 #pragma weak mpi_iscan_ = ompi_iscan_f
diff --git a/ompi/mpi/fortran/mpif-h/iscatter_f.c b/ompi/mpi/fortran/mpif-h/iscatter_f.c
index 9c954bdcf66..70518bff4f1 100644
--- a/ompi/mpi/fortran/mpif-h/iscatter_f.c
+++ b/ompi/mpi/fortran/mpif-h/iscatter_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ISCATTER = ompi_iscatter_f
 #pragma weak pmpi_iscatter = ompi_iscatter_f
 #pragma weak pmpi_iscatter_ = ompi_iscatter_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ISCATTER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ISCATTER = ompi_iscatter_f
 #pragma weak mpi_iscatter = ompi_iscatter_f
 #pragma weak mpi_iscatter_ = ompi_iscatter_f
diff --git a/ompi/mpi/fortran/mpif-h/iscatterv_f.c b/ompi/mpi/fortran/mpif-h/iscatterv_f.c
index 01226a83ea8..f83af6c6be9 100644
--- a/ompi/mpi/fortran/mpif-h/iscatterv_f.c
+++ b/ompi/mpi/fortran/mpif-h/iscatterv_f.c
@@ -13,6 +13,8 @@
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -27,7 +29,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ISCATTERV = ompi_iscatterv_f
 #pragma weak pmpi_iscatterv = ompi_iscatterv_f
 #pragma weak pmpi_iscatterv_ = ompi_iscatterv_f
@@ -46,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ISCATTERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ISCATTERV = ompi_iscatterv_f
 #pragma weak mpi_iscatterv = ompi_iscatterv_f
 #pragma weak mpi_iscatterv_ = ompi_iscatterv_f
@@ -78,7 +80,7 @@ void ompi_iscatterv_f(char *sendbuf, MPI_Fint *sendcounts,
     MPI_Comm c_comm;
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(displs);
 
@@ -108,11 +110,10 @@ void ompi_iscatterv_f(char *sendbuf, MPI_Fint *sendcounts,
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sendcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(displs);
     } else {
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(displs);
+        if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
     }
 }
diff --git a/ompi/mpi/fortran/mpif-h/isend_f.c b/ompi/mpi/fortran/mpif-h/isend_f.c
index d29a9933a06..084a20174c7 100644
--- a/ompi/mpi/fortran/mpif-h/isend_f.c
+++ b/ompi/mpi/fortran/mpif-h/isend_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ISEND = ompi_isend_f
 #pragma weak pmpi_isend = ompi_isend_f
 #pragma weak pmpi_isend_ = ompi_isend_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ISEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ISEND = ompi_isend_f
 #pragma weak mpi_isend = ompi_isend_f
 #pragma weak mpi_isend_ = ompi_isend_f
diff --git a/ompi/mpi/fortran/mpif-h/isendrecv_f.c b/ompi/mpi/fortran/mpif-h/isendrecv_f.c
index cf010ad0803..914b57d92e5 100644
--- a/ompi/mpi/fortran/mpif-h/isendrecv_f.c
+++ b/ompi/mpi/fortran/mpif-h/isendrecv_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ISENDRECV = ompi_isendrecv_f
 #pragma weak pmpi_isendrecv = ompi_isendrecv_f
 #pragma weak pmpi_isendrecv_ = ompi_isendrecv_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ISENDRECV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ISENDRECV = ompi_isendrecv_f
 #pragma weak mpi_isendrecv = ompi_isendrecv_f
 #pragma weak mpi_isendrecv_ = ompi_isendrecv_f
diff --git a/ompi/mpi/fortran/mpif-h/isendrecv_replace_f.c b/ompi/mpi/fortran/mpif-h/isendrecv_replace_f.c
index 37d69588d2b..38175cb7108 100644
--- a/ompi/mpi/fortran/mpif-h/isendrecv_replace_f.c
+++ b/ompi/mpi/fortran/mpif-h/isendrecv_replace_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ISENDRECV_REPLACE = ompi_isendrecv_replace_f
 #pragma weak pmpi_isendrecv_replace = ompi_isendrecv_replace_f
 #pragma weak pmpi_isendrecv_replace_ = ompi_isendrecv_replace_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ISENDRECV_REPLACE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ISENDRECV_REPLACE = ompi_isendrecv_replace_f
 #pragma weak mpi_isendrecv_replace = ompi_isendrecv_replace_f
 #pragma weak mpi_isendrecv_replace_ = ompi_isendrecv_replace_f
diff --git a/ompi/mpi/fortran/mpif-h/issend_f.c b/ompi/mpi/fortran/mpif-h/issend_f.c
index ae299e98888..511f1bc3d3b 100644
--- a/ompi/mpi/fortran/mpif-h/issend_f.c
+++ b/ompi/mpi/fortran/mpif-h/issend_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_ISSEND = ompi_issend_f
 #pragma weak pmpi_issend = ompi_issend_f
 #pragma weak pmpi_issend_ = ompi_issend_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_ISSEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_ISSEND = ompi_issend_f
 #pragma weak mpi_issend = ompi_issend_f
 #pragma weak mpi_issend_ = ompi_issend_f
diff --git a/ompi/mpi/fortran/mpif-h/keyval_create_f.c b/ompi/mpi/fortran/mpif-h/keyval_create_f.c
index 4ad5c51ca67..8cd2a1eb7fe 100644
--- a/ompi/mpi/fortran/mpif-h/keyval_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/keyval_create_f.c
@@ -25,7 +25,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_KEYVAL_CREATE = ompi_keyval_create_f
 #pragma weak pmpi_keyval_create = ompi_keyval_create_f
 #pragma weak pmpi_keyval_create_ = ompi_keyval_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS(PMPI_KEYVAL_CREATE, pmpi_keyval_create, pmpi_keyval_c
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_KEYVAL_CREATE = ompi_keyval_create_f
 #pragma weak mpi_keyval_create = ompi_keyval_create_f
 #pragma weak mpi_keyval_create_ = ompi_keyval_create_f
diff --git a/ompi/mpi/fortran/mpif-h/keyval_free_f.c b/ompi/mpi/fortran/mpif-h/keyval_free_f.c
index e836b689ebb..06a26c23cff 100644
--- a/ompi/mpi/fortran/mpif-h/keyval_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/keyval_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_KEYVAL_FREE = ompi_keyval_free_f
 #pragma weak pmpi_keyval_free = ompi_keyval_free_f
 #pragma weak pmpi_keyval_free_ = ompi_keyval_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_KEYVAL_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_KEYVAL_FREE = ompi_keyval_free_f
 #pragma weak mpi_keyval_free = ompi_keyval_free_f
 #pragma weak mpi_keyval_free_ = ompi_keyval_free_f
diff --git a/ompi/mpi/fortran/mpif-h/lookup_name_f.c b/ompi/mpi/fortran/mpif-h/lookup_name_f.c
index 3f17c626ea9..cc8aa0e866a 100644
--- a/ompi/mpi/fortran/mpif-h/lookup_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/lookup_name_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_LOOKUP_NAME = ompi_lookup_name_f
 #pragma weak pmpi_lookup_name = ompi_lookup_name_f
 #pragma weak pmpi_lookup_name_ = ompi_lookup_name_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_LOOKUP_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_LOOKUP_NAME = ompi_lookup_name_f
 #pragma weak mpi_lookup_name = ompi_lookup_name_f
 #pragma weak mpi_lookup_name_ = ompi_lookup_name_f
diff --git a/ompi/mpi/fortran/mpif-h/mprobe_f.c b/ompi/mpi/fortran/mpif-h/mprobe_f.c
index 0558e9543f8..45854cde4f6 100644
--- a/ompi/mpi/fortran/mpif-h/mprobe_f.c
+++ b/ompi/mpi/fortran/mpif-h/mprobe_f.c
@@ -30,7 +30,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_MPROBE = ompi_mprobe_f
 #pragma weak pmpi_mprobe = ompi_mprobe_f
 #pragma weak pmpi_mprobe_ = ompi_mprobe_f
@@ -50,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_MPROBE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_MPROBE = ompi_mprobe_f
 #pragma weak mpi_mprobe = ompi_mprobe_f
 #pragma weak mpi_mprobe_ = ompi_mprobe_f
diff --git a/ompi/mpi/fortran/mpif-h/mrecv_f.c b/ompi/mpi/fortran/mpif-h/mrecv_f.c
index 8a898ce7f5d..6dcda839153 100644
--- a/ompi/mpi/fortran/mpif-h/mrecv_f.c
+++ b/ompi/mpi/fortran/mpif-h/mrecv_f.c
@@ -29,7 +29,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_MRECV = ompi_mrecv_f
 #pragma weak pmpi_mrecv = ompi_mrecv_f
 #pragma weak pmpi_mrecv_ = ompi_mrecv_f
@@ -49,7 +49,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_MRECV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_MRECV = ompi_mrecv_f
 #pragma weak mpi_mrecv = ompi_mrecv_f
 #pragma weak mpi_mrecv_ = ompi_mrecv_f
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_allgather_f.c b/ompi/mpi/fortran/mpif-h/neighbor_allgather_f.c
index e0ffdf083a1..8713add1f9c 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_allgather_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_allgather_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLGATHER = ompi_neighbor_allgather_f
 #pragma weak pmpi_neighbor_allgather = ompi_neighbor_allgather_f
 #pragma weak pmpi_neighbor_allgather_ = ompi_neighbor_allgather_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLGATHER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLGATHER = ompi_neighbor_allgather_f
 #pragma weak mpi_neighbor_allgather = ompi_neighbor_allgather_f
 #pragma weak mpi_neighbor_allgather_ = ompi_neighbor_allgather_f
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_allgather_init_f.c b/ompi/mpi/fortran/mpif-h/neighbor_allgather_init_f.c
index ab6f9df6605..eef5d40dd7f 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_allgather_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_allgather_init_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLGATHER_INIT = ompi_neighbor_allgather_init_f
 #pragma weak pmpi_neighbor_allgather_init = ompi_neighbor_allgather_init_f
 #pragma weak pmpi_neighbor_allgather_init_ = ompi_neighbor_allgather_init_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLGATHER_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLGATHER_INIT = ompi_neighbor_allgather_init_f
 #pragma weak mpi_neighbor_allgather_init = ompi_neighbor_allgather_init_f
 #pragma weak mpi_neighbor_allgather_init_ = ompi_neighbor_allgather_init_f
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_f.c b/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_f.c
index 0008ca3185c..32f079143af 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLGATHERV = ompi_neighbor_allgatherv_f
 #pragma weak pmpi_neighbor_allgatherv = ompi_neighbor_allgatherv_f
 #pragma weak pmpi_neighbor_allgatherv_ = ompi_neighbor_allgatherv_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLGATHERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLGATHERV = ompi_neighbor_allgatherv_f
 #pragma weak mpi_neighbor_allgatherv = ompi_neighbor_allgatherv_f
 #pragma weak mpi_neighbor_allgatherv_ = ompi_neighbor_allgatherv_f
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_init_f.c b/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_init_f.c
index 532365e2aa7..8453d01acd3 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_allgatherv_init_f.c
@@ -15,6 +15,8 @@
  *                         reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -29,7 +31,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLGATHERV_INIT = ompi_neighbor_allgatherv_init_f
 #pragma weak pmpi_neighbor_allgatherv_init = ompi_neighbor_allgatherv_init_f
 #pragma weak pmpi_neighbor_allgatherv_init_ = ompi_neighbor_allgatherv_init_f
@@ -48,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLGATHERV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLGATHERV_INIT = ompi_neighbor_allgatherv_init_f
 #pragma weak mpi_neighbor_allgatherv_init = ompi_neighbor_allgatherv_init_f
 #pragma weak mpi_neighbor_allgatherv_init_ = ompi_neighbor_allgatherv_init_f
@@ -108,11 +110,10 @@ void ompi_neighbor_allgatherv_init_f(char *sendbuf, MPI_Fint *sendcount, MPI_Fin
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(ierr_c);
     if (MPI_SUCCESS == ierr_c) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (recvcounts != OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
-            nb_request->data.release_arrays[0] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[1] = OMPI_ARRAY_NAME_CONVERT(displs);
-            nb_request->data.release_arrays[2] = NULL;
+        if ((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
     } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_alltoall_f.c b/ompi/mpi/fortran/mpif-h/neighbor_alltoall_f.c
index 57e28e2a119..3d523b1bab3 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_alltoall_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_alltoall_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLTOALL = ompi_neighbor_alltoall_f
 #pragma weak pmpi_neighbor_alltoall = ompi_neighbor_alltoall_f
 #pragma weak pmpi_neighbor_alltoall_ = ompi_neighbor_alltoall_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLTOALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLTOALL = ompi_neighbor_alltoall_f
 #pragma weak mpi_neighbor_alltoall = ompi_neighbor_alltoall_f
 #pragma weak mpi_neighbor_alltoall_ = ompi_neighbor_alltoall_f
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_alltoall_init_f.c b/ompi/mpi/fortran/mpif-h/neighbor_alltoall_init_f.c
index 509cba401ca..f0dfb79f948 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_alltoall_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_alltoall_init_f.c
@@ -29,7 +29,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLTOALL_INIT = ompi_neighbor_alltoall_init_f
 #pragma weak pmpi_neighbor_alltoall_init = ompi_neighbor_alltoall_init_f
 #pragma weak pmpi_neighbor_alltoall_init_ = ompi_neighbor_alltoall_init_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLTOALL_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLTOALL_INIT = ompi_neighbor_alltoall_init_f
 #pragma weak mpi_neighbor_alltoall_init = ompi_neighbor_alltoall_init_f
 #pragma weak mpi_neighbor_alltoall_init_ = ompi_neighbor_alltoall_init_f
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_f.c b/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_f.c
index e9b96425e94..10583e851a0 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_f.c
@@ -15,6 +15,8 @@
  *                         reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,9 +28,10 @@
 
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 #include "ompi/mpi/fortran/base/constants.h"
+#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLTOALLV = ompi_neighbor_alltoallv_f
 #pragma weak pmpi_neighbor_alltoallv = ompi_neighbor_alltoallv_f
 #pragma weak pmpi_neighbor_alltoallv_ = ompi_neighbor_alltoallv_f
@@ -47,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLTOALLV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLTOALLV = ompi_neighbor_alltoallv_f
 #pragma weak mpi_neighbor_alltoallv = ompi_neighbor_alltoallv_f
 #pragma weak mpi_neighbor_alltoallv_ = ompi_neighbor_alltoallv_f
@@ -77,7 +80,7 @@ void ompi_neighbor_alltoallv_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *sd
 {
     MPI_Comm c_comm;
     MPI_Datatype c_sendtype, c_recvtype;
-    int size, c_ierr;
+    int indegree, outdegree, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(sdispls);
     OMPI_ARRAY_NAME_DECL(recvcounts);
@@ -87,11 +90,16 @@ void ompi_neighbor_alltoallv_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fint *sd
     c_sendtype = PMPI_Type_f2c(*sendtype);
     c_recvtype = PMPI_Type_f2c(*recvtype);
 
-    PMPI_Comm_size(c_comm, &size);
-    OMPI_ARRAY_FINT_2_INT(sendcounts, size);
-    OMPI_ARRAY_FINT_2_INT(sdispls, size);
-    OMPI_ARRAY_FINT_2_INT(recvcounts, size);
-    OMPI_ARRAY_FINT_2_INT(rdispls, size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        return;
+    }
+
+    OMPI_ARRAY_FINT_2_INT(sendcounts, outdegree);
+    OMPI_ARRAY_FINT_2_INT(sdispls, outdegree);
+    OMPI_ARRAY_FINT_2_INT(recvcounts, indegree);
+    OMPI_ARRAY_FINT_2_INT(rdispls, indegree);
 
     sendbuf = (char *) OMPI_F2C_IN_PLACE(sendbuf);
     sendbuf = (char *) OMPI_F2C_BOTTOM(sendbuf);
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_init_f.c b/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_init_f.c
index 27ffadbc446..b3ee66d49a4 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_alltoallv_init_f.c
@@ -15,6 +15,8 @@
  *                         reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025-2026 Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,10 +28,11 @@
 
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 #include "ompi/mpi/fortran/base/constants.h"
+#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLTOALLV_INIT = ompi_neighbor_alltoallv_init_f
 #pragma weak pmpi_neighbor_alltoallv_init = ompi_neighbor_alltoallv_init_f
 #pragma weak pmpi_neighbor_alltoallv_init_ = ompi_neighbor_alltoallv_init_f
@@ -48,7 +51,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLTOALLV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLTOALLV_INIT = ompi_neighbor_alltoallv_init_f
 #pragma weak mpi_neighbor_alltoallv_init = ompi_neighbor_alltoallv_init_f
 #pragma weak mpi_neighbor_alltoallv_init_ = ompi_neighbor_alltoallv_init_f
@@ -80,7 +83,7 @@ void ompi_neighbor_alltoallv_init_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fin
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Info c_info;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int indegree, outdegree, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(sdispls);
     OMPI_ARRAY_NAME_DECL(recvcounts);
@@ -91,11 +94,16 @@ void ompi_neighbor_alltoallv_init_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fin
     c_recvtype = PMPI_Type_f2c(*recvtype);
     c_info = PMPI_Info_f2c(*info);
 
-    PMPI_Comm_size(c_comm, &size);
-    OMPI_ARRAY_FINT_2_INT(sendcounts, size);
-    OMPI_ARRAY_FINT_2_INT(sdispls, size);
-    OMPI_ARRAY_FINT_2_INT(recvcounts, size);
-    OMPI_ARRAY_FINT_2_INT(rdispls, size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        return;
+    }
+
+    OMPI_ARRAY_FINT_2_INT(sendcounts, outdegree);
+    OMPI_ARRAY_FINT_2_INT(sdispls, outdegree);
+    OMPI_ARRAY_FINT_2_INT(recvcounts, indegree);
+    OMPI_ARRAY_FINT_2_INT(rdispls, indegree);
 
     sendbuf = (char *) OMPI_F2C_IN_PLACE(sendbuf);
     sendbuf = (char *) OMPI_F2C_BOTTOM(sendbuf);
@@ -112,14 +120,13 @@ void ompi_neighbor_alltoallv_init_f(char *sendbuf, MPI_Fint *sendcounts, MPI_Fin
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sdispls);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(rdispls);
+        if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sdispls));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(rdispls));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx] = NULL;
     } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sendcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sdispls);
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_f.c b/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_f.c
index f5a34a36e1c..9d850cef454 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_f.c
@@ -15,6 +15,8 @@
  *                         reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,9 +28,10 @@
 
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 #include "ompi/mpi/fortran/base/constants.h"
+#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLTOALLW = ompi_neighbor_alltoallw_f
 #pragma weak pmpi_neighbor_alltoallw = ompi_neighbor_alltoallw_f
 #pragma weak pmpi_neighbor_alltoallw_ = ompi_neighbor_alltoallw_f
@@ -47,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLTOALLW,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLTOALLW = ompi_neighbor_alltoallw_f
 #pragma weak mpi_neighbor_alltoallw = ompi_neighbor_alltoallw_f
 #pragma weak mpi_neighbor_alltoallw_ = ompi_neighbor_alltoallw_f
@@ -78,23 +81,31 @@ void ompi_neighbor_alltoallw_f(char *sendbuf, MPI_Fint *sendcounts,
 {
     MPI_Comm c_comm;
     MPI_Datatype *c_sendtypes, *c_recvtypes;
-    int size, c_ierr;
+    int indegree, outdegree, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(recvcounts);
 
     c_comm = PMPI_Comm_f2c(*comm);
-    PMPI_Comm_size(c_comm, &size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        return;
+    }
 
-    c_sendtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
-    c_recvtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+    c_sendtypes = (MPI_Datatype *) malloc(outdegree * sizeof(MPI_Datatype));
+    c_recvtypes = (MPI_Datatype *) malloc(indegree * sizeof(MPI_Datatype));
 
-    OMPI_ARRAY_FINT_2_INT(sendcounts, size);
-    OMPI_ARRAY_FINT_2_INT(recvcounts, size);
+    OMPI_ARRAY_FINT_2_INT(sendcounts, outdegree);
+    OMPI_ARRAY_FINT_2_INT(recvcounts, indegree);
+
+    while (outdegree > 0) {
+        c_sendtypes[outdegree - 1] = PMPI_Type_f2c(sendtypes[outdegree - 1]);
+        --outdegree;
+    }
 
-    while (size > 0) {
-        c_sendtypes[size - 1] = PMPI_Type_f2c(sendtypes[size - 1]);
-        c_recvtypes[size - 1] = PMPI_Type_f2c(recvtypes[size - 1]);
-        --size;
+    while (indegree > 0) {
+        c_recvtypes[indegree - 1] = PMPI_Type_f2c(recvtypes[indegree - 1]);
+        --indegree;
     }
 
     /* Alltoallw does not support MPI_IN_PLACE */
diff --git a/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_init_f.c b/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_init_f.c
index 59910c88e36..7b36eca265f 100644
--- a/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/neighbor_alltoallw_init_f.c
@@ -15,6 +15,8 @@
  *                         reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025-2026 Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,10 +28,11 @@
 
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 #include "ompi/mpi/fortran/base/constants.h"
+#include "ompi/mpi/fortran/base/fortran_base_topo_neighbors.h"
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_NEIGHBOR_ALLTOALLW_INIT = ompi_neighbor_alltoallw_init_f
 #pragma weak pmpi_neighbor_alltoallw_init = ompi_neighbor_alltoallw_init_f
 #pragma weak pmpi_neighbor_alltoallw_init_ = ompi_neighbor_alltoallw_init_f
@@ -48,7 +51,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_NEIGHBOR_ALLTOALLW_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_NEIGHBOR_ALLTOALLW_INIT = ompi_neighbor_alltoallw_init_f
 #pragma weak mpi_neighbor_alltoallw_init = ompi_neighbor_alltoallw_init_f
 #pragma weak mpi_neighbor_alltoallw_init_ = ompi_neighbor_alltoallw_init_f
@@ -81,24 +84,33 @@ void ompi_neighbor_alltoallw_init_f(char *sendbuf, MPI_Fint *sendcounts,
     MPI_Datatype *c_sendtypes, *c_recvtypes;
     MPI_Info c_info;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int indegree, outdegree, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(recvcounts);
 
     c_comm = PMPI_Comm_f2c(*comm);
     c_info = PMPI_Info_f2c(*info);
-    PMPI_Comm_size(c_comm, &size);
 
-    c_sendtypes = (MPI_Datatype *) malloc(2* size * sizeof(MPI_Datatype));
-    c_recvtypes = c_sendtypes + size;
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        return;
+    }
+
+    c_sendtypes = (MPI_Datatype *) malloc(outdegree * sizeof(MPI_Datatype));
+    c_recvtypes = (MPI_Datatype *) malloc(indegree * sizeof(MPI_Datatype));
 
-    OMPI_ARRAY_FINT_2_INT(sendcounts, size);
-    OMPI_ARRAY_FINT_2_INT(recvcounts, size);
+    OMPI_ARRAY_FINT_2_INT(sendcounts, outdegree);
+    OMPI_ARRAY_FINT_2_INT(recvcounts, indegree);
+
+    while (outdegree > 0) {
+        c_sendtypes[outdegree - 1] = PMPI_Type_f2c(sendtypes[outdegree - 1]);
+        --outdegree;
+    }
 
-    while (size > 0) {
-        c_sendtypes[size - 1] = PMPI_Type_f2c(sendtypes[size - 1]);
-        c_recvtypes[size - 1] = PMPI_Type_f2c(recvtypes[size - 1]);
-        --size;
+    while (indegree > 0) {
+        c_recvtypes[indegree - 1] = PMPI_Type_f2c(recvtypes[indegree - 1]);
+        --indegree;
     }
 
     /* Neighbor_alltoallw_init does not support MPI_IN_PLACE */
@@ -116,13 +128,12 @@ void ompi_neighbor_alltoallw_init_f(char *sendbuf, MPI_Fint *sendcounts,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        nb_request->data.release_arrays[idx++] = c_sendtypes;
-        if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
+        ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
+        if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
         }
-        nb_request->data.release_arrays[idx]   = NULL;
+        ompi_coll_base_add_release_arrays_cb(c_request);
     } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sendcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
diff --git a/ompi/mpi/fortran/mpif-h/op_commutative_f.c b/ompi/mpi/fortran/mpif-h/op_commutative_f.c
index f4c5b72ee1a..bfbc0686818 100644
--- a/ompi/mpi/fortran/mpif-h/op_commutative_f.c
+++ b/ompi/mpi/fortran/mpif-h/op_commutative_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_OP_COMMUTATIVE = ompi_op_commutative_f
 #pragma weak pmpi_op_commutative = ompi_op_commutative_f
 #pragma weak pmpi_op_commutative_ = ompi_op_commutative_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_OP_COMMUTATIVE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_OP_COMMUTATIVE = ompi_op_commutative_f
 #pragma weak mpi_op_commutative = ompi_op_commutative_f
 #pragma weak mpi_op_commutative_ = ompi_op_commutative_f
diff --git a/ompi/mpi/fortran/mpif-h/op_create_f.c b/ompi/mpi/fortran/mpif-h/op_create_f.c
index 05334a07015..02bbd77412b 100644
--- a/ompi/mpi/fortran/mpif-h/op_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/op_create_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_OP_CREATE = ompi_op_create_f
 #pragma weak pmpi_op_create = ompi_op_create_f
 #pragma weak pmpi_op_create_ = ompi_op_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_OP_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_OP_CREATE = ompi_op_create_f
 #pragma weak mpi_op_create = ompi_op_create_f
 #pragma weak mpi_op_create_ = ompi_op_create_f
diff --git a/ompi/mpi/fortran/mpif-h/op_free_f.c b/ompi/mpi/fortran/mpif-h/op_free_f.c
index c3efbd3ba06..44cab0ba58f 100644
--- a/ompi/mpi/fortran/mpif-h/op_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/op_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_OP_FREE = ompi_op_free_f
 #pragma weak pmpi_op_free = ompi_op_free_f
 #pragma weak pmpi_op_free_ = ompi_op_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_OP_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_OP_FREE = ompi_op_free_f
 #pragma weak mpi_op_free = ompi_op_free_f
 #pragma weak mpi_op_free_ = ompi_op_free_f
diff --git a/ompi/mpi/fortran/mpif-h/open_port_f.c b/ompi/mpi/fortran/mpif-h/open_port_f.c
index 60f0c553275..8ec2e37580d 100644
--- a/ompi/mpi/fortran/mpif-h/open_port_f.c
+++ b/ompi/mpi/fortran/mpif-h/open_port_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_OPEN_PORT = ompi_open_port_f
 #pragma weak pmpi_open_port = ompi_open_port_f
 #pragma weak pmpi_open_port_ = ompi_open_port_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_OPEN_PORT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_OPEN_PORT = ompi_open_port_f
 #pragma weak mpi_open_port = ompi_open_port_f
 #pragma weak mpi_open_port_ = ompi_open_port_f
diff --git a/ompi/mpi/fortran/mpif-h/pack_external_f.c b/ompi/mpi/fortran/mpif-h/pack_external_f.c
index 5bebea71cd9..e1d7ccd8146 100644
--- a/ompi/mpi/fortran/mpif-h/pack_external_f.c
+++ b/ompi/mpi/fortran/mpif-h/pack_external_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PACK_EXTERNAL = ompi_pack_external_f
 #pragma weak pmpi_pack_external = ompi_pack_external_f
 #pragma weak pmpi_pack_external_ = ompi_pack_external_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PACK_EXTERNAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PACK_EXTERNAL = ompi_pack_external_f
 #pragma weak mpi_pack_external = ompi_pack_external_f
 #pragma weak mpi_pack_external_ = ompi_pack_external_f
diff --git a/ompi/mpi/fortran/mpif-h/pack_external_size_f.c b/ompi/mpi/fortran/mpif-h/pack_external_size_f.c
index 9e6410ee57d..1f5c0213901 100644
--- a/ompi/mpi/fortran/mpif-h/pack_external_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/pack_external_size_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PACK_EXTERNAL_SIZE = ompi_pack_external_size_f
 #pragma weak pmpi_pack_external_size = ompi_pack_external_size_f
 #pragma weak pmpi_pack_external_size_ = ompi_pack_external_size_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PACK_EXTERNAL_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PACK_EXTERNAL_SIZE = ompi_pack_external_size_f
 #pragma weak mpi_pack_external_size = ompi_pack_external_size_f
 #pragma weak mpi_pack_external_size_ = ompi_pack_external_size_f
diff --git a/ompi/mpi/fortran/mpif-h/pack_f.c b/ompi/mpi/fortran/mpif-h/pack_f.c
index 9006c59ad28..474ec341e7c 100644
--- a/ompi/mpi/fortran/mpif-h/pack_f.c
+++ b/ompi/mpi/fortran/mpif-h/pack_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PACK = ompi_pack_f
 #pragma weak pmpi_pack = ompi_pack_f
 #pragma weak pmpi_pack_ = ompi_pack_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PACK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PACK = ompi_pack_f
 #pragma weak mpi_pack = ompi_pack_f
 #pragma weak mpi_pack_ = ompi_pack_f
diff --git a/ompi/mpi/fortran/mpif-h/pack_size_f.c b/ompi/mpi/fortran/mpif-h/pack_size_f.c
index b6376e1fe79..884342ca385 100644
--- a/ompi/mpi/fortran/mpif-h/pack_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/pack_size_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PACK_SIZE = ompi_pack_size_f
 #pragma weak pmpi_pack_size = ompi_pack_size_f
 #pragma weak pmpi_pack_size_ = ompi_pack_size_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PACK_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PACK_SIZE = ompi_pack_size_f
 #pragma weak mpi_pack_size = ompi_pack_size_f
 #pragma weak mpi_pack_size_ = ompi_pack_size_f
diff --git a/ompi/mpi/fortran/mpif-h/parrived_f.c b/ompi/mpi/fortran/mpif-h/parrived_f.c
index 2dda6cbd4c4..df7d25831db 100644
--- a/ompi/mpi/fortran/mpif-h/parrived_f.c
+++ b/ompi/mpi/fortran/mpif-h/parrived_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PARRIVED = ompi_parrived_f
 #pragma weak pmpi_parrived = ompi_parrived_f
 #pragma weak pmpi_parrived_ = ompi_parrived_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PARRIVED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PARRIVED = ompi_parrived_f
 #pragma weak mpi_parrived = ompi_parrived_f
 #pragma weak mpi_parrived_ = ompi_parrived_f
diff --git a/ompi/mpi/fortran/mpif-h/pcontrol_f.c b/ompi/mpi/fortran/mpif-h/pcontrol_f.c
index 6150496a2d0..10a4c923182 100644
--- a/ompi/mpi/fortran/mpif-h/pcontrol_f.c
+++ b/ompi/mpi/fortran/mpif-h/pcontrol_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PCONTROL = ompi_pcontrol_f
 #pragma weak pmpi_pcontrol = ompi_pcontrol_f
 #pragma weak pmpi_pcontrol_ = ompi_pcontrol_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PCONTROL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PCONTROL = ompi_pcontrol_f
 #pragma weak mpi_pcontrol = ompi_pcontrol_f
 #pragma weak mpi_pcontrol_ = ompi_pcontrol_f
diff --git a/ompi/mpi/fortran/mpif-h/pready_f.c b/ompi/mpi/fortran/mpif-h/pready_f.c
index e4fa7c81c5f..e1c89f92fc3 100644
--- a/ompi/mpi/fortran/mpif-h/pready_f.c
+++ b/ompi/mpi/fortran/mpif-h/pready_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PREADY = ompi_pready_f
 #pragma weak pmpi_pready = ompi_pready_f
 #pragma weak pmpi_pready_ = ompi_pready_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PREADY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PREADY = ompi_pready_f
 #pragma weak mpi_pready = ompi_pready_f
 #pragma weak mpi_pready_ = ompi_pready_f
diff --git a/ompi/mpi/fortran/mpif-h/pready_list_f.c b/ompi/mpi/fortran/mpif-h/pready_list_f.c
index fdbf85d6d58..d8c83c9c430 100644
--- a/ompi/mpi/fortran/mpif-h/pready_list_f.c
+++ b/ompi/mpi/fortran/mpif-h/pready_list_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PREADY_LIST = ompi_pready_list_f
 #pragma weak pmpi_pready_list = ompi_pready_list_f
 #pragma weak pmpi_pready_list_ = ompi_pready_list_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PREADY_LIST,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PREADY_LIST = ompi_pready_list_f
 #pragma weak mpi_pready_list = ompi_pready_list_f
 #pragma weak mpi_pready_list_ = ompi_pready_list_f
diff --git a/ompi/mpi/fortran/mpif-h/pready_range_f.c b/ompi/mpi/fortran/mpif-h/pready_range_f.c
index 958a260dcba..dc7e8f3ac18 100644
--- a/ompi/mpi/fortran/mpif-h/pready_range_f.c
+++ b/ompi/mpi/fortran/mpif-h/pready_range_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PREADY_RANGE = ompi_pready_range_f
 #pragma weak pmpi_pready_range = ompi_pready_range_f
 #pragma weak pmpi_pready_range_ = ompi_pready_range_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PREADY_RANGE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PREADY_RANGE = ompi_pready_range_f
 #pragma weak mpi_pready_range = ompi_pready_range_f
 #pragma weak mpi_pready_range_ = ompi_pready_range_f
diff --git a/ompi/mpi/fortran/mpif-h/precv_init_f.c b/ompi/mpi/fortran/mpif-h/precv_init_f.c
index 2fe64d55c55..eaeaee87927 100644
--- a/ompi/mpi/fortran/mpif-h/precv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/precv_init_f.c
@@ -29,7 +29,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PRECV_INIT = ompi_precv_init_f
 #pragma weak pmpi_precv_init = ompi_precv_init_f
 #pragma weak pmpi_precv_init_ = ompi_precv_init_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PRECV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PRECV_INIT = ompi_precv_init_f
 #pragma weak mpi_precv_init = ompi_precv_init_f
 #pragma weak mpi_precv_init_ = ompi_precv_init_f
diff --git a/ompi/mpi/fortran/mpif-h/probe_f.c b/ompi/mpi/fortran/mpif-h/probe_f.c
index 76774cb1a68..5d1bc6408d6 100644
--- a/ompi/mpi/fortran/mpif-h/probe_f.c
+++ b/ompi/mpi/fortran/mpif-h/probe_f.c
@@ -28,7 +28,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PROBE = ompi_probe_f
 #pragma weak pmpi_probe = ompi_probe_f
 #pragma weak pmpi_probe_ = ompi_probe_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PROBE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PROBE = ompi_probe_f
 #pragma weak mpi_probe = ompi_probe_f
 #pragma weak mpi_probe_ = ompi_probe_f
diff --git a/ompi/mpi/fortran/mpif-h/profile/Makefile.am b/ompi/mpi/fortran/mpif-h/profile/Makefile.am
index 88e495b56db..9a93ca47306 100644
--- a/ompi/mpi/fortran/mpif-h/profile/Makefile.am
+++ b/ompi/mpi/fortran/mpif-h/profile/Makefile.am
@@ -364,9 +364,15 @@ linked_files = \
         pstart_f.c \
         pstatus_f082f_f.c \
         pstatus_f2f08_f.c \
+        pstatus_get_error_f.c \
+        pstatus_get_source_f.c \
+        pstatus_get_tag_f.c \
         pstatus_set_cancelled_f.c \
         pstatus_set_elements_f.c \
         pstatus_set_elements_x_f.c \
+        pstatus_set_error_f.c \
+        pstatus_set_source_f.c \
+        pstatus_set_tag_f.c \
         ptestall_f.c \
         ptestany_f.c \
         ptest_cancelled_f.c \
diff --git a/ompi/mpi/fortran/mpif-h/prototypes_mpi.h b/ompi/mpi/fortran/mpif-h/prototypes_mpi.h
index 931d019dce7..39f0bd2160e 100644
--- a/ompi/mpi/fortran/mpif-h/prototypes_mpi.h
+++ b/ompi/mpi/fortran/mpif-h/prototypes_mpi.h
@@ -422,9 +422,15 @@ PN2(void, MPI_Start, mpi_start, MPI_START, (MPI_Fint *request, MPI_Fint *ierr));
 PN2(void, MPI_Startall, mpi_startall, MPI_STARTALL, (MPI_Fint *count, MPI_Fint *array_of_requests, MPI_Fint *ierr));
 PN2(void, MPI_Status_f082f, mpi_status_f082f, MPI_STATUS_F082F, (const MPI_F08_status *f08_status, MPI_Fint *f_status, MPI_Fint *ierr));
 PN2(void, MPI_Status_f2f08, mpi_status_f2f08, MPI_STATUS_F2F08, (const MPI_Fint *f_status, MPI_F08_status *f08_status, MPI_Fint *ierr));
+PN2(void, MPI_Status_get_error, mpi_status_get_error, MPI_STATUS_GET_ERROR, (MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr));
+PN2(void, MPI_Status_get_source, mpi_status_get_source, MPI_STATUS_GET_SOURCE, (MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr));
+PN2(void, MPI_Status_get_tag, mpi_status_get_tag, MPI_STATUS_GET_TAG, (MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr));
 PN2(void, MPI_Status_set_cancelled, mpi_status_set_cancelled, MPI_STATUS_SET_CANCELLED, (MPI_Fint *status, ompi_fortran_logical_t *flag, MPI_Fint *ierr));
 PN2(void, MPI_Status_set_elements, mpi_status_set_elements, MPI_STATUS_SET_ELEMENTS, (MPI_Fint *status, MPI_Fint *datatype, MPI_Fint *count, MPI_Fint *ierr));
 PN2(void, MPI_Status_set_elements_x, mpi_status_set_elements_x, MPI_STATUS_SET_ELEMENTS_X, (MPI_Fint *status, MPI_Fint *datatype, MPI_Count *count, MPI_Fint *ierr));
+PN2(void, MPI_Status_set_error, mpi_status_set_error, MPI_STATUS_SET_ERROR, (MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr));
+PN2(void, MPI_Status_set_source, mpi_status_set_source, MPI_STATUS_SET_SOURCE, (MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr));
+PN2(void, MPI_Status_set_tag, mpi_status_set_tag, MPI_STATUS_SET_TAG, (MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr));
 PN2(void, MPI_Testall, mpi_testall, MPI_TESTALL, (MPI_Fint *count, MPI_Fint *array_of_requests, ompi_fortran_logical_t *flag, MPI_Fint *array_of_statuses, MPI_Fint *ierr));
 PN2(void, MPI_Testany, mpi_testany, MPI_TESTANY, (MPI_Fint *count, MPI_Fint *array_of_requests, MPI_Fint *index, ompi_fortran_logical_t *flag, MPI_Fint *status, MPI_Fint *ierr));
 PN2(void, MPI_Test, mpi_test, MPI_TEST, (MPI_Fint *request, ompi_fortran_logical_t *flag, MPI_Fint *status, MPI_Fint *ierr));
diff --git a/ompi/mpi/fortran/mpif-h/psend_init_f.c b/ompi/mpi/fortran/mpif-h/psend_init_f.c
index 5325b9eb7d0..6531757199f 100644
--- a/ompi/mpi/fortran/mpif-h/psend_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/psend_init_f.c
@@ -29,7 +29,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PSEND_INIT = ompi_psend_init_f
 #pragma weak pmpi_psend_init = ompi_psend_init_f
 #pragma weak pmpi_psend_init_ = ompi_psend_init_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PSEND_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PSEND_INIT = ompi_psend_init_f
 #pragma weak mpi_psend_init = ompi_psend_init_f
 #pragma weak mpi_psend_init_ = ompi_psend_init_f
diff --git a/ompi/mpi/fortran/mpif-h/publish_name_f.c b/ompi/mpi/fortran/mpif-h/publish_name_f.c
index d219e564a0a..aa569b2326e 100644
--- a/ompi/mpi/fortran/mpif-h/publish_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/publish_name_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PUBLISH_NAME = ompi_publish_name_f
 #pragma weak pmpi_publish_name = ompi_publish_name_f
 #pragma weak pmpi_publish_name_ = ompi_publish_name_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PUBLISH_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PUBLISH_NAME = ompi_publish_name_f
 #pragma weak mpi_publish_name = ompi_publish_name_f
 #pragma weak mpi_publish_name_ = ompi_publish_name_f
diff --git a/ompi/mpi/fortran/mpif-h/put_f.c b/ompi/mpi/fortran/mpif-h/put_f.c
index 686166e1bc8..93155012acb 100644
--- a/ompi/mpi/fortran/mpif-h/put_f.c
+++ b/ompi/mpi/fortran/mpif-h/put_f.c
@@ -26,7 +26,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_PUT = ompi_put_f
 #pragma weak pmpi_put = ompi_put_f
 #pragma weak pmpi_put_ = ompi_put_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_PUT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_PUT = ompi_put_f
 #pragma weak mpi_put = ompi_put_f
 #pragma weak mpi_put_ = ompi_put_f
diff --git a/ompi/mpi/fortran/mpif-h/query_thread_f.c b/ompi/mpi/fortran/mpif-h/query_thread_f.c
index e3bf2b39a6d..57bddbdd97e 100644
--- a/ompi/mpi/fortran/mpif-h/query_thread_f.c
+++ b/ompi/mpi/fortran/mpif-h/query_thread_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_QUERY_THREAD = ompi_query_thread_f
 #pragma weak pmpi_query_thread = ompi_query_thread_f
 #pragma weak pmpi_query_thread_ = ompi_query_thread_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_QUERY_THREAD,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_QUERY_THREAD = ompi_query_thread_f
 #pragma weak mpi_query_thread = ompi_query_thread_f
 #pragma weak mpi_query_thread_ = ompi_query_thread_f
diff --git a/ompi/mpi/fortran/mpif-h/raccumulate_f.c b/ompi/mpi/fortran/mpif-h/raccumulate_f.c
index 2c631871312..45dfda54c2a 100644
--- a/ompi/mpi/fortran/mpif-h/raccumulate_f.c
+++ b/ompi/mpi/fortran/mpif-h/raccumulate_f.c
@@ -29,7 +29,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RACCUMULATE = ompi_raccumulate_f
 #pragma weak pmpi_raccumulate = ompi_raccumulate_f
 #pragma weak pmpi_raccumulate_ = ompi_raccumulate_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RACCUMULATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RACCUMULATE = ompi_raccumulate_f
 #pragma weak mpi_raccumulate = ompi_raccumulate_f
 #pragma weak mpi_raccumulate_ = ompi_raccumulate_f
diff --git a/ompi/mpi/fortran/mpif-h/recv_f.c b/ompi/mpi/fortran/mpif-h/recv_f.c
index 2d933075284..643600870c7 100644
--- a/ompi/mpi/fortran/mpif-h/recv_f.c
+++ b/ompi/mpi/fortran/mpif-h/recv_f.c
@@ -28,7 +28,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RECV = ompi_recv_f
 #pragma weak pmpi_recv = ompi_recv_f
 #pragma weak pmpi_recv_ = ompi_recv_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RECV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RECV = ompi_recv_f
 #pragma weak mpi_recv = ompi_recv_f
 #pragma weak mpi_recv_ = ompi_recv_f
diff --git a/ompi/mpi/fortran/mpif-h/recv_init_f.c b/ompi/mpi/fortran/mpif-h/recv_init_f.c
index 8fea063296e..cea6ad67266 100644
--- a/ompi/mpi/fortran/mpif-h/recv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/recv_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RECV_INIT = ompi_recv_init_f
 #pragma weak pmpi_recv_init = ompi_recv_init_f
 #pragma weak pmpi_recv_init_ = ompi_recv_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RECV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RECV_INIT = ompi_recv_init_f
 #pragma weak mpi_recv_init = ompi_recv_init_f
 #pragma weak mpi_recv_init_ = ompi_recv_init_f
diff --git a/ompi/mpi/fortran/mpif-h/reduce_f.c b/ompi/mpi/fortran/mpif-h/reduce_f.c
index bf26152f344..13b48b23ebd 100644
--- a/ompi/mpi/fortran/mpif-h/reduce_f.c
+++ b/ompi/mpi/fortran/mpif-h/reduce_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REDUCE = ompi_reduce_f
 #pragma weak pmpi_reduce = ompi_reduce_f
 #pragma weak pmpi_reduce_ = ompi_reduce_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REDUCE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REDUCE = ompi_reduce_f
 #pragma weak mpi_reduce = ompi_reduce_f
 #pragma weak mpi_reduce_ = ompi_reduce_f
diff --git a/ompi/mpi/fortran/mpif-h/reduce_init_f.c b/ompi/mpi/fortran/mpif-h/reduce_init_f.c
index 01437078cdc..0aeff49ef2d 100644
--- a/ompi/mpi/fortran/mpif-h/reduce_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/reduce_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REDUCE_INIT = ompi_reduce_init_f
 #pragma weak pmpi_reduce_init = ompi_reduce_init_f
 #pragma weak pmpi_reduce_init_ = ompi_reduce_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REDUCE_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REDUCE_INIT = ompi_reduce_init_f
 #pragma weak mpi_reduce_init = ompi_reduce_init_f
 #pragma weak mpi_reduce_init_ = ompi_reduce_init_f
diff --git a/ompi/mpi/fortran/mpif-h/reduce_local_f.c b/ompi/mpi/fortran/mpif-h/reduce_local_f.c
index a7134e4baac..5cd20b45a3a 100644
--- a/ompi/mpi/fortran/mpif-h/reduce_local_f.c
+++ b/ompi/mpi/fortran/mpif-h/reduce_local_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REDUCE_LOCAL = ompi_reduce_local_f
 #pragma weak pmpi_reduce_local = ompi_reduce_local_f
 #pragma weak pmpi_reduce_local_ = ompi_reduce_local_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REDUCE_LOCAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REDUCE_LOCAL = ompi_reduce_local_f
 #pragma weak mpi_reduce_local = ompi_reduce_local_f
 #pragma weak mpi_reduce_local_ = ompi_reduce_local_f
diff --git a/ompi/mpi/fortran/mpif-h/reduce_scatter_block_f.c b/ompi/mpi/fortran/mpif-h/reduce_scatter_block_f.c
index c70cef7baf1..db84704f76d 100644
--- a/ompi/mpi/fortran/mpif-h/reduce_scatter_block_f.c
+++ b/ompi/mpi/fortran/mpif-h/reduce_scatter_block_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REDUCE_SCATTER_BLOCK = ompi_reduce_scatter_block_f
 #pragma weak pmpi_reduce_scatter_block = ompi_reduce_scatter_block_f
 #pragma weak pmpi_reduce_scatter_block_ = ompi_reduce_scatter_block_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REDUCE_SCATTER_BLOCK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REDUCE_SCATTER_BLOCK = ompi_reduce_scatter_block_f
 #pragma weak mpi_reduce_scatter_block = ompi_reduce_scatter_block_f
 #pragma weak mpi_reduce_scatter_block_ = ompi_reduce_scatter_block_f
diff --git a/ompi/mpi/fortran/mpif-h/reduce_scatter_block_init_f.c b/ompi/mpi/fortran/mpif-h/reduce_scatter_block_init_f.c
index 1bc36af0f7f..88fce6c53ab 100644
--- a/ompi/mpi/fortran/mpif-h/reduce_scatter_block_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/reduce_scatter_block_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REDUCE_SCATTER_BLOCK_INIT = ompi_reduce_scatter_block_init_f
 #pragma weak pmpi_reduce_scatter_block_init = ompi_reduce_scatter_block_init_f
 #pragma weak pmpi_reduce_scatter_block_init_ = ompi_reduce_scatter_block_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REDUCE_SCATTER_BLOCK_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REDUCE_SCATTER_BLOCK_INIT = ompi_reduce_scatter_block_init_f
 #pragma weak mpi_reduce_scatter_block_init = ompi_reduce_scatter_block_init_f
 #pragma weak mpi_reduce_scatter_block_init_ = ompi_reduce_scatter_block_init_f
diff --git a/ompi/mpi/fortran/mpif-h/reduce_scatter_f.c b/ompi/mpi/fortran/mpif-h/reduce_scatter_f.c
index c5cd1881643..4b895d8731e 100644
--- a/ompi/mpi/fortran/mpif-h/reduce_scatter_f.c
+++ b/ompi/mpi/fortran/mpif-h/reduce_scatter_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REDUCE_SCATTER = ompi_reduce_scatter_f
 #pragma weak pmpi_reduce_scatter = ompi_reduce_scatter_f
 #pragma weak pmpi_reduce_scatter_ = ompi_reduce_scatter_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REDUCE_SCATTER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REDUCE_SCATTER = ompi_reduce_scatter_f
 #pragma weak mpi_reduce_scatter = ompi_reduce_scatter_f
 #pragma weak mpi_reduce_scatter_ = ompi_reduce_scatter_f
diff --git a/ompi/mpi/fortran/mpif-h/reduce_scatter_init_f.c b/ompi/mpi/fortran/mpif-h/reduce_scatter_init_f.c
index d60a69dbfef..b0c5f68497c 100644
--- a/ompi/mpi/fortran/mpif-h/reduce_scatter_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/reduce_scatter_init_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REDUCE_SCATTER_INIT = ompi_reduce_scatter_init_f
 #pragma weak pmpi_reduce_scatter_init = ompi_reduce_scatter_init_f
 #pragma weak pmpi_reduce_scatter_init_ = ompi_reduce_scatter_init_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REDUCE_SCATTER_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REDUCE_SCATTER_INIT = ompi_reduce_scatter_init_f
 #pragma weak mpi_reduce_scatter_init = ompi_reduce_scatter_init_f
 #pragma weak mpi_reduce_scatter_init_ = ompi_reduce_scatter_init_f
@@ -100,9 +102,10 @@ void ompi_reduce_scatter_init_f(char *sendbuf, char *recvbuf,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        nb_request->data.release_arrays[0] = OMPI_ARRAY_NAME_CONVERT(recvcounts);
-        nb_request->data.release_arrays[1] = NULL;
+        if((void *)recvcounts != (void *)OMPI_ARRAY_NAME_CONVERT(recvcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(recvcounts));
+            ompi_coll_base_add_release_arrays_cb(c_request);
+        }
     } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(recvcounts);
     }
diff --git a/ompi/mpi/fortran/mpif-h/register_datarep_f.c b/ompi/mpi/fortran/mpif-h/register_datarep_f.c
index 63e31191ba3..200b55af51a 100644
--- a/ompi/mpi/fortran/mpif-h/register_datarep_f.c
+++ b/ompi/mpi/fortran/mpif-h/register_datarep_f.c
@@ -33,7 +33,7 @@
 #include "ompi/file/file.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REGISTER_DATAREP = ompi_register_datarep_f
 #pragma weak pmpi_register_datarep = ompi_register_datarep_f
 #pragma weak pmpi_register_datarep_ = ompi_register_datarep_f
@@ -52,7 +52,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REGISTER_DATAREP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REGISTER_DATAREP = ompi_register_datarep_f
 #pragma weak mpi_register_datarep = ompi_register_datarep_f
 #pragma weak mpi_register_datarep_ = ompi_register_datarep_f
@@ -100,7 +100,7 @@ typedef struct intercept_extra_state {
 
 OBJ_CLASS_DECLARATION(ompi_intercept_extra_state_t);
 
-#if !OMPI_BUILD_MPI_PROFILING || OPAL_HAVE_WEAK_SYMBOLS
+#if !OMPI_BUILD_MPI_PROFILING || OPAL_HAVE_WEAK_ALIASES
 static void intercept_extra_state_constructor(ompi_intercept_extra_state_t *obj)
 {
     obj->read_fn_f77 = NULL;
diff --git a/ompi/mpi/fortran/mpif-h/remove_error_class_f.c b/ompi/mpi/fortran/mpif-h/remove_error_class_f.c
index 2eeb4ad2d09..74313a487fa 100644
--- a/ompi/mpi/fortran/mpif-h/remove_error_class_f.c
+++ b/ompi/mpi/fortran/mpif-h/remove_error_class_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REMOVE_ERROR_CLASS = ompi_remove_error_class_f
 #pragma weak pmpi_remove_error_class = ompi_remove_error_class_f
 #pragma weak pmpi_remove_error_class_ = ompi_remove_error_class_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REMOVE_ERROR_CLASS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REMOVE_ERROR_CLASS = ompi_remove_error_class_f
 #pragma weak mpi_remove_error_class = ompi_remove_error_class_f
 #pragma weak mpi_remove_error_class_ = ompi_remove_error_class_f
diff --git a/ompi/mpi/fortran/mpif-h/remove_error_code_f.c b/ompi/mpi/fortran/mpif-h/remove_error_code_f.c
index f9889cb6d64..904471b8de4 100644
--- a/ompi/mpi/fortran/mpif-h/remove_error_code_f.c
+++ b/ompi/mpi/fortran/mpif-h/remove_error_code_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REMOVE_ERROR_CODE = ompi_remove_error_code_f
 #pragma weak pmpi_remove_error_code = ompi_remove_error_code_f
 #pragma weak pmpi_remove_error_code_ = ompi_remove_error_code_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REMOVE_ERROR_CODE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REMOVE_ERROR_CODE = ompi_remove_error_code_f
 #pragma weak mpi_remove_error_code = ompi_remove_error_code_f
 #pragma weak mpi_remove_error_code_ = ompi_remove_error_code_f
diff --git a/ompi/mpi/fortran/mpif-h/remove_error_string_f.c b/ompi/mpi/fortran/mpif-h/remove_error_string_f.c
index 09b7ecddd1b..f109ad1e6e2 100644
--- a/ompi/mpi/fortran/mpif-h/remove_error_string_f.c
+++ b/ompi/mpi/fortran/mpif-h/remove_error_string_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REMOVE_ERROR_STRING = ompi_remove_error_string_f
 #pragma weak pmpi_remove_error_string = ompi_remove_error_string_f
 #pragma weak pmpi_remove_error_string_ = ompi_remove_error_string_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REMOVE_ERROR_STRING,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REMOVE_ERROR_STRING = ompi_remove_error_string_f
 #pragma weak mpi_remove_error_string = ompi_remove_error_string_f
 #pragma weak mpi_remove_error_string_ = ompi_remove_error_string_f
diff --git a/ompi/mpi/fortran/mpif-h/request_free_f.c b/ompi/mpi/fortran/mpif-h/request_free_f.c
index 6ab32d4b56c..2b4034c24a8 100644
--- a/ompi/mpi/fortran/mpif-h/request_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/request_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REQUEST_FREE = ompi_request_free_f
 #pragma weak pmpi_request_free = ompi_request_free_f
 #pragma weak pmpi_request_free_ = ompi_request_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REQUEST_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REQUEST_FREE = ompi_request_free_f
 #pragma weak mpi_request_free = ompi_request_free_f
 #pragma weak mpi_request_free_ = ompi_request_free_f
diff --git a/ompi/mpi/fortran/mpif-h/request_get_status_all_f.c b/ompi/mpi/fortran/mpif-h/request_get_status_all_f.c
index 0b5ce05cbe4..ca5e6190521 100644
--- a/ompi/mpi/fortran/mpif-h/request_get_status_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/request_get_status_all_f.c
@@ -29,7 +29,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REQUEST_GET_STATUS_ALL = ompi_request_get_status_all_f
 #pragma weak pmpi_request_get_status_all = ompi_request_get_status_all_f
 #pragma weak pmpi_request_get_status_all_ = ompi_request_get_status_all_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REQUEST_GET_STATUS_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REQUEST_GET_STATUS_ALL = ompi_request_get_status_all_f
 #pragma weak mpi_request_get_status_all = ompi_request_get_status_all_f
 #pragma weak mpi_request_get_status_all_ = ompi_request_get_status_all_f
diff --git a/ompi/mpi/fortran/mpif-h/request_get_status_any_f.c b/ompi/mpi/fortran/mpif-h/request_get_status_any_f.c
index 2215328b681..ed5b4439bd4 100644
--- a/ompi/mpi/fortran/mpif-h/request_get_status_any_f.c
+++ b/ompi/mpi/fortran/mpif-h/request_get_status_any_f.c
@@ -29,7 +29,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REQUEST_STATUS_GET_ANY = ompi_request_get_status_any_f
 #pragma weak pmpi_request_get_status_any = ompi_request_get_status_any_f
 #pragma weak pmpi_request_get_status_any_ = ompi_request_get_status_any_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REQUEST_STATUS_GET_ANY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REQUEST_STATUS_GET_ANY = ompi_request_get_status_any_f
 #pragma weak mpi_request_get_status_any = ompi_request_get_status_any_f
 #pragma weak mpi_request_get_status_any_ = ompi_request_get_status_any_f
diff --git a/ompi/mpi/fortran/mpif-h/request_get_status_f.c b/ompi/mpi/fortran/mpif-h/request_get_status_f.c
index 7fac2b2e051..7794af05c97 100644
--- a/ompi/mpi/fortran/mpif-h/request_get_status_f.c
+++ b/ompi/mpi/fortran/mpif-h/request_get_status_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REQUEST_GET_STATUS = ompi_request_get_status_f
 #pragma weak pmpi_request_get_status = ompi_request_get_status_f
 #pragma weak pmpi_request_get_status_ = ompi_request_get_status_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REQUEST_GET_STATUS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REQUEST_GET_STATUS = ompi_request_get_status_f
 #pragma weak mpi_request_get_status = ompi_request_get_status_f
 #pragma weak mpi_request_get_status_ = ompi_request_get_status_f
diff --git a/ompi/mpi/fortran/mpif-h/request_get_status_some_f.c b/ompi/mpi/fortran/mpif-h/request_get_status_some_f.c
index 6cae95847e5..c07ca739085 100644
--- a/ompi/mpi/fortran/mpif-h/request_get_status_some_f.c
+++ b/ompi/mpi/fortran/mpif-h/request_get_status_some_f.c
@@ -29,7 +29,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_REQUEST_GET_STATUS_SOME = ompi_request_get_status_some_f
 #pragma weak pmpi_request_get_status_some = ompi_request_get_status_some_f
 #pragma weak pmpi_request_get_status_some_ = ompi_request_get_status_some_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_REQUEST_GET_STATUS_SOME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_REQUEST_GET_STATUS_SOME = ompi_request_get_status_some_f
 #pragma weak mpi_request_get_status_some = ompi_request_get_status_some_f
 #pragma weak mpi_request_get_status_some_ = ompi_request_get_status_some_f
diff --git a/ompi/mpi/fortran/mpif-h/rget_accumulate_f.c b/ompi/mpi/fortran/mpif-h/rget_accumulate_f.c
index 57fa6470227..c5ecded16d8 100644
--- a/ompi/mpi/fortran/mpif-h/rget_accumulate_f.c
+++ b/ompi/mpi/fortran/mpif-h/rget_accumulate_f.c
@@ -30,7 +30,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RGET_ACCUMULATE = ompi_rget_accumulate_f
 #pragma weak pmpi_rget_accumulate = ompi_rget_accumulate_f
 #pragma weak pmpi_rget_accumulate_ = ompi_rget_accumulate_f
@@ -49,7 +49,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RGET_ACCUMULATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RGET_ACCUMULATE = ompi_rget_accumulate_f
 #pragma weak mpi_rget_accumulate = ompi_rget_accumulate_f
 #pragma weak mpi_rget_accumulate_ = ompi_rget_accumulate_f
diff --git a/ompi/mpi/fortran/mpif-h/rget_f.c b/ompi/mpi/fortran/mpif-h/rget_f.c
index a6c77d36f2d..4bc5f500cf8 100644
--- a/ompi/mpi/fortran/mpif-h/rget_f.c
+++ b/ompi/mpi/fortran/mpif-h/rget_f.c
@@ -29,7 +29,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RGET = ompi_rget_f
 #pragma weak pmpi_rget = ompi_rget_f
 #pragma weak pmpi_rget_ = ompi_rget_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RGET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RGET = ompi_rget_f
 #pragma weak mpi_rget = ompi_rget_f
 #pragma weak mpi_rget_ = ompi_rget_f
diff --git a/ompi/mpi/fortran/mpif-h/rput_f.c b/ompi/mpi/fortran/mpif-h/rput_f.c
index 03125bcc894..d4002c9bdab 100644
--- a/ompi/mpi/fortran/mpif-h/rput_f.c
+++ b/ompi/mpi/fortran/mpif-h/rput_f.c
@@ -29,7 +29,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RPUT = ompi_rput_f
 #pragma weak pmpi_rput = ompi_rput_f
 #pragma weak pmpi_rput_ = ompi_rput_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RPUT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RPUT = ompi_rput_f
 #pragma weak mpi_rput = ompi_rput_f
 #pragma weak mpi_rput_ = ompi_rput_f
diff --git a/ompi/mpi/fortran/mpif-h/rsend_f.c b/ompi/mpi/fortran/mpif-h/rsend_f.c
index eed76ee3658..93d19c286bb 100644
--- a/ompi/mpi/fortran/mpif-h/rsend_f.c
+++ b/ompi/mpi/fortran/mpif-h/rsend_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RSEND = ompi_rsend_f
 #pragma weak pmpi_rsend = ompi_rsend_f
 #pragma weak pmpi_rsend_ = ompi_rsend_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RSEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RSEND = ompi_rsend_f
 #pragma weak mpi_rsend = ompi_rsend_f
 #pragma weak mpi_rsend_ = ompi_rsend_f
diff --git a/ompi/mpi/fortran/mpif-h/rsend_init_f.c b/ompi/mpi/fortran/mpif-h/rsend_init_f.c
index d0e9e2bd0fe..d05fe676dbd 100644
--- a/ompi/mpi/fortran/mpif-h/rsend_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/rsend_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_RSEND_INIT = ompi_rsend_init_f
 #pragma weak pmpi_rsend_init = ompi_rsend_init_f
 #pragma weak pmpi_rsend_init_ = ompi_rsend_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_RSEND_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_RSEND_INIT = ompi_rsend_init_f
 #pragma weak mpi_rsend_init = ompi_rsend_init_f
 #pragma weak mpi_rsend_init_ = ompi_rsend_init_f
diff --git a/ompi/mpi/fortran/mpif-h/scan_f.c b/ompi/mpi/fortran/mpif-h/scan_f.c
index cff6012ca4a..b2c0c74629f 100644
--- a/ompi/mpi/fortran/mpif-h/scan_f.c
+++ b/ompi/mpi/fortran/mpif-h/scan_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SCAN = ompi_scan_f
 #pragma weak pmpi_scan = ompi_scan_f
 #pragma weak pmpi_scan_ = ompi_scan_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SCAN,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SCAN = ompi_scan_f
 #pragma weak mpi_scan = ompi_scan_f
 #pragma weak mpi_scan_ = ompi_scan_f
diff --git a/ompi/mpi/fortran/mpif-h/scan_init_f.c b/ompi/mpi/fortran/mpif-h/scan_init_f.c
index a58d237b942..76279e9e8a0 100644
--- a/ompi/mpi/fortran/mpif-h/scan_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/scan_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SCAN_INIT = ompi_scan_init_f
 #pragma weak pmpi_scan_init = ompi_scan_init_f
 #pragma weak pmpi_scan_init_ = ompi_scan_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SCAN_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SCAN_INIT = ompi_scan_init_f
 #pragma weak mpi_scan_init = ompi_scan_init_f
 #pragma weak mpi_scan_init_ = ompi_scan_init_f
diff --git a/ompi/mpi/fortran/mpif-h/scatter_f.c b/ompi/mpi/fortran/mpif-h/scatter_f.c
index 667a7064dd5..cafe446dac2 100644
--- a/ompi/mpi/fortran/mpif-h/scatter_f.c
+++ b/ompi/mpi/fortran/mpif-h/scatter_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SCATTER = ompi_scatter_f
 #pragma weak pmpi_scatter = ompi_scatter_f
 #pragma weak pmpi_scatter_ = ompi_scatter_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SCATTER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SCATTER = ompi_scatter_f
 #pragma weak mpi_scatter = ompi_scatter_f
 #pragma weak mpi_scatter_ = ompi_scatter_f
diff --git a/ompi/mpi/fortran/mpif-h/scatter_init_f.c b/ompi/mpi/fortran/mpif-h/scatter_init_f.c
index 2f6f3e7fdb9..a1409827c13 100644
--- a/ompi/mpi/fortran/mpif-h/scatter_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/scatter_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SCATTER_INIT = ompi_scatter_init_f
 #pragma weak pmpi_scatter_init = ompi_scatter_init_f
 #pragma weak pmpi_scatter_init_ = ompi_scatter_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SCATTER_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SCATTER_INIT = ompi_scatter_init_f
 #pragma weak mpi_scatter_init = ompi_scatter_init_f
 #pragma weak mpi_scatter_init_ = ompi_scatter_init_f
diff --git a/ompi/mpi/fortran/mpif-h/scatterv_f.c b/ompi/mpi/fortran/mpif-h/scatterv_f.c
index 744a05fe02c..f9ae44548b6 100644
--- a/ompi/mpi/fortran/mpif-h/scatterv_f.c
+++ b/ompi/mpi/fortran/mpif-h/scatterv_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SCATTERV = ompi_scatterv_f
 #pragma weak pmpi_scatterv = ompi_scatterv_f
 #pragma weak pmpi_scatterv_ = ompi_scatterv_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SCATTERV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SCATTERV = ompi_scatterv_f
 #pragma weak mpi_scatterv = ompi_scatterv_f
 #pragma weak mpi_scatterv_ = ompi_scatterv_f
diff --git a/ompi/mpi/fortran/mpif-h/scatterv_init_f.c b/ompi/mpi/fortran/mpif-h/scatterv_init_f.c
index 394984214dd..46eb50600d0 100644
--- a/ompi/mpi/fortran/mpif-h/scatterv_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/scatterv_init_f.c
@@ -12,6 +12,8 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2025      Triad National Security, LLC. All rights
+ *                         reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -26,7 +28,7 @@
 #include "ompi/mca/coll/base/coll_base_util.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SCATTERV_INIT = ompi_scatterv_init_f
 #pragma weak pmpi_scatterv_init = ompi_scatterv_init_f
 #pragma weak pmpi_scatterv_init_ = ompi_scatterv_init_f
@@ -45,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SCATTERV_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SCATTERV_INIT = ompi_scatterv_init_f
 #pragma weak mpi_scatterv_init = ompi_scatterv_init_f
 #pragma weak mpi_scatterv_init_ = ompi_scatterv_init_f
@@ -78,7 +80,7 @@ void ompi_scatterv_init_f(char *sendbuf, MPI_Fint *sendcounts,
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Info c_info;
     MPI_Request c_request;
-    int size, idx = 0, c_ierr;
+    int size, c_ierr;
     OMPI_ARRAY_NAME_DECL(sendcounts);
     OMPI_ARRAY_NAME_DECL(displs);
 
@@ -105,12 +107,11 @@ void ompi_scatterv_init_f(char *sendbuf, MPI_Fint *sendcounts,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
-        ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request;
-        if (sendcounts != OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(sendcounts);
-            nb_request->data.release_arrays[idx++] = OMPI_ARRAY_NAME_CONVERT(displs);
+        if ((void *)sendcounts != (void *)OMPI_ARRAY_NAME_CONVERT(sendcounts)) {
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(sendcounts));
+            ompi_coll_base_append_array_to_release(c_request, OMPI_ARRAY_NAME_CONVERT(displs));
+            ompi_coll_base_add_release_arrays_cb(c_request);
         }
-        nb_request->data.release_arrays[idx]   = NULL;
      } else {
         OMPI_ARRAY_FINT_2_INT_CLEANUP(sendcounts);
         OMPI_ARRAY_FINT_2_INT_CLEANUP(displs);
diff --git a/ompi/mpi/fortran/mpif-h/send_f.c b/ompi/mpi/fortran/mpif-h/send_f.c
index 60a244d6855..a463edaa07a 100644
--- a/ompi/mpi/fortran/mpif-h/send_f.c
+++ b/ompi/mpi/fortran/mpif-h/send_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SEND = ompi_send_f
 #pragma weak pmpi_send = ompi_send_f
 #pragma weak pmpi_send_ = ompi_send_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SEND = ompi_send_f
 #pragma weak mpi_send = ompi_send_f
 #pragma weak mpi_send_ = ompi_send_f
diff --git a/ompi/mpi/fortran/mpif-h/send_init_f.c b/ompi/mpi/fortran/mpif-h/send_init_f.c
index c406d315c9e..f34a914c598 100644
--- a/ompi/mpi/fortran/mpif-h/send_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/send_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SEND_INIT = ompi_send_init_f
 #pragma weak pmpi_send_init = ompi_send_init_f
 #pragma weak pmpi_send_init_ = ompi_send_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SEND_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SEND_INIT = ompi_send_init_f
 #pragma weak mpi_send_init = ompi_send_init_f
 #pragma weak mpi_send_init_ = ompi_send_init_f
diff --git a/ompi/mpi/fortran/mpif-h/sendrecv_f.c b/ompi/mpi/fortran/mpif-h/sendrecv_f.c
index 4772fce4f32..512505cac11 100644
--- a/ompi/mpi/fortran/mpif-h/sendrecv_f.c
+++ b/ompi/mpi/fortran/mpif-h/sendrecv_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SENDRECV = ompi_sendrecv_f
 #pragma weak pmpi_sendrecv = ompi_sendrecv_f
 #pragma weak pmpi_sendrecv_ = ompi_sendrecv_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SENDRECV,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SENDRECV = ompi_sendrecv_f
 #pragma weak mpi_sendrecv = ompi_sendrecv_f
 #pragma weak mpi_sendrecv_ = ompi_sendrecv_f
diff --git a/ompi/mpi/fortran/mpif-h/sendrecv_replace_f.c b/ompi/mpi/fortran/mpif-h/sendrecv_replace_f.c
index 5a6a0ed79e7..4179b270d33 100644
--- a/ompi/mpi/fortran/mpif-h/sendrecv_replace_f.c
+++ b/ompi/mpi/fortran/mpif-h/sendrecv_replace_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SENDRECV_REPLACE = ompi_sendrecv_replace_f
 #pragma weak pmpi_sendrecv_replace = ompi_sendrecv_replace_f
 #pragma weak pmpi_sendrecv_replace_ = ompi_sendrecv_replace_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SENDRECV_REPLACE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SENDRECV_REPLACE = ompi_sendrecv_replace_f
 #pragma weak mpi_sendrecv_replace = ompi_sendrecv_replace_f
 #pragma weak mpi_sendrecv_replace_ = ompi_sendrecv_replace_f
diff --git a/ompi/mpi/fortran/mpif-h/session_attach_buffer_f.c b/ompi/mpi/fortran/mpif-h/session_attach_buffer_f.c
index c2d57f55bbd..cf6c908ce5f 100644
--- a/ompi/mpi/fortran/mpif-h/session_attach_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_attach_buffer_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_ATTACH_BUFFER = ompi_session_attach_buffer_f
 #pragma weak pmpi_session_attach_buffer = ompi_session_attach_buffer_f
 #pragma weak pmpi_session_attach_buffer_ = ompi_session_attach_buffer_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_ATTACH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_ATTACH_BUFFER = ompi_session_attach_buffer_f
 #pragma weak mpi_session_attach_buffer = ompi_session_attach_buffer_f
 #pragma weak mpi_session_attach_buffer_ = ompi_session_attach_buffer_f
diff --git a/ompi/mpi/fortran/mpif-h/session_call_errhandler_f.c b/ompi/mpi/fortran/mpif-h/session_call_errhandler_f.c
index deb4360c752..3d5558dfb91 100644
--- a/ompi/mpi/fortran/mpif-h/session_call_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_call_errhandler_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_CALL_ERRHANDLER = ompi_session_call_errhandler_f
 #pragma weak pmpi_session_call_errhandler = ompi_session_call_errhandler_f
 #pragma weak pmpi_session_call_errhandler_ = ompi_session_call_errhandler_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_CALL_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_CALL_ERRHANDLER = ompi_session_call_errhandler_f
 #pragma weak mpi_session_call_errhandler = ompi_session_call_errhandler_f
 #pragma weak mpi_session_call_errhandler_ = ompi_session_call_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/session_create_errhandler_f.c b/ompi/mpi/fortran/mpif-h/session_create_errhandler_f.c
index bf97f332570..8ea7c11eb0a 100644
--- a/ompi/mpi/fortran/mpif-h/session_create_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_create_errhandler_f.c
@@ -26,7 +26,7 @@
 #include "ompi/instance/instance.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_CREATE_ERRHANDLER = ompi_session_create_errhandler_f
 #pragma weak pmpi_session_create_errhandler = ompi_session_create_errhandler_f
 #pragma weak pmpi_session_create_errhandler_ = ompi_session_create_errhandler_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_CREATE_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_CREATE_ERRHANDLER = ompi_session_create_errhandler_f
 #pragma weak mpi_session_create_errhandler = ompi_session_create_errhandler_f
 #pragma weak mpi_session_create_errhandler_ = ompi_session_create_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/session_detach_buffer_f.c b/ompi/mpi/fortran/mpif-h/session_detach_buffer_f.c
index 4e04b1a7c08..a4fdb0c15e0 100644
--- a/ompi/mpi/fortran/mpif-h/session_detach_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_detach_buffer_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_DETACH_BUFFER = ompi_session_detach_buffer_f
 #pragma weak pmpi_session_detach_buffer = ompi_session_detach_buffer_f
 #pragma weak pmpi_session_detach_buffer_ = ompi_session_detach_buffer_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_DETACH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_DETACH_BUFFER = ompi_session_detach_buffer_f
 #pragma weak mpi_session_detach_buffer = ompi_session_detach_buffer_f
 #pragma weak mpi_session_detach_buffer_ = ompi_session_detach_buffer_f
@@ -76,7 +76,7 @@ OMPI_GENERATE_F77_BINDINGS (MPI_SESSION_DETACH_BUFFER,
  * The mpi_f08 implementation for MPI_BUFFER_DETACH therefore is a
  * separate routine in the use-mpi-f08 directory (it's not built in
  * the mpif-h directory because of all the different combinations of
- * supporting weak symbols (or not), building the profiling layer (or
+ * supporting weak aliases (or not), building the profiling layer (or
  * not), etc.).
  */
 void ompi_session_detach_buffer_f(MPI_Fint *session, char *buffer, MPI_Fint *size, MPI_Fint *ierr)
diff --git a/ompi/mpi/fortran/mpif-h/session_finalize_f.c b/ompi/mpi/fortran/mpif-h/session_finalize_f.c
index 4a7d44127e9..8e9566c87ac 100644
--- a/ompi/mpi/fortran/mpif-h/session_finalize_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_finalize_f.c
@@ -29,7 +29,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_FINALIZE = ompi_session_finalize_f
 #pragma weak pmpi_session_finalize = ompi_session_finalize_f
 #pragma weak pmpi_session_finalize_ = ompi_session_finalize_f
@@ -49,7 +49,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_FINALIZE,
 #endif
 
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_FINALIZE = ompi_session_finalize_f
 #pragma weak mpi_session_finalize = ompi_session_finalize_f
 #pragma weak mpi_session_finalize_ = ompi_session_finalize_f
diff --git a/ompi/mpi/fortran/mpif-h/session_flush_buffer_f.c b/ompi/mpi/fortran/mpif-h/session_flush_buffer_f.c
index cf333ad810e..b71c0efcb3f 100644
--- a/ompi/mpi/fortran/mpif-h/session_flush_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_flush_buffer_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_FLUSH_BUFFER = ompi_session_flush_buffer_f
 #pragma weak pmpi_session_flush_buffer = ompi_session_flush_buffer_f
 #pragma weak pmpi_session_flush_buffer_ = ompi_session_flush_buffer_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_FLUSH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_FLUSH_BUFFER = ompi_session_flush_buffer_f
 #pragma weak mpi_session_flush_buffer = ompi_session_flush_buffer_f
 #pragma weak mpi_session_flush_buffer_ = ompi_session_flush_buffer_f
diff --git a/ompi/mpi/fortran/mpif-h/session_get_errhandler_f.c b/ompi/mpi/fortran/mpif-h/session_get_errhandler_f.c
index 9ea6ce1941a..00b5996bf33 100644
--- a/ompi/mpi/fortran/mpif-h/session_get_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_get_errhandler_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_GET_ERRHANDLER = ompi_session_get_errhandler_f
 #pragma weak pmpi_session_get_errhandler = ompi_session_get_errhandler_f
 #pragma weak pmpi_session_get_errhandler_ = ompi_session_get_errhandler_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_GET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_GET_ERRHANDLER = ompi_session_get_errhandler_f
 #pragma weak mpi_session_get_errhandler = ompi_session_get_errhandler_f
 #pragma weak mpi_session_get_errhandler_ = ompi_session_get_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/session_get_info_f.c b/ompi/mpi/fortran/mpif-h/session_get_info_f.c
index 2172c33b7ff..6e9311286ec 100644
--- a/ompi/mpi/fortran/mpif-h/session_get_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_get_info_f.c
@@ -30,7 +30,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_GET_INFO = ompi_session_get_info_f
 #pragma weak pmpi_session_get_info = ompi_session_get_info_f
 #pragma weak pmpi_session_get_info_ = ompi_session_get_info_f
@@ -49,7 +49,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_GET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_GET_INFO = ompi_session_get_info_f
 #pragma weak mpi_session_get_info = ompi_session_get_info_f
 #pragma weak mpi_session_get_info_ = ompi_session_get_info_f
diff --git a/ompi/mpi/fortran/mpif-h/session_get_nth_pset_f.c b/ompi/mpi/fortran/mpif-h/session_get_nth_pset_f.c
index f221274417f..e356549e700 100644
--- a/ompi/mpi/fortran/mpif-h/session_get_nth_pset_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_get_nth_pset_f.c
@@ -32,7 +32,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_GET_NTH_PSET = ompi_session_get_nth_pset_f
 #pragma weak pmpi_session_get_nth_pset = ompi_session_get_nth_pset_f
 #pragma weak pmpi_session_get_nth_pset_ = ompi_session_get_nth_pset_f
@@ -51,7 +51,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_GET_NTH_PSET,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_GET_NTH_PSET = ompi_session_get_nth_pset_f
 #pragma weak mpi_session_get_nth_pset = ompi_session_get_nth_pset_f
 #pragma weak mpi_session_get_nth_pset_ = ompi_session_get_nth_pset_f
diff --git a/ompi/mpi/fortran/mpif-h/session_get_num_psets_f.c b/ompi/mpi/fortran/mpif-h/session_get_num_psets_f.c
index f1498395e78..6ddb9f65b11 100644
--- a/ompi/mpi/fortran/mpif-h/session_get_num_psets_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_get_num_psets_f.c
@@ -29,7 +29,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_GET_NUM_PSETS = ompi_session_get_num_psets_f
 #pragma weak pmpi_session_get_num_psets = ompi_session_get_num_psets_f
 #pragma weak pmpi_session_get_num_psets_ = ompi_session_get_num_psets_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_GET_NUM_PSETS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_GET_NUM_PSETS = ompi_session_get_num_psets_f
 #pragma weak mpi_session_get_num_psets = ompi_session_get_num_psets_f
 #pragma weak mpi_session_get_num_psets_ = ompi_session_get_num_psets_f
diff --git a/ompi/mpi/fortran/mpif-h/session_get_pset_info_f.c b/ompi/mpi/fortran/mpif-h/session_get_pset_info_f.c
index fb3b4cbed57..3e0437e6d9f 100644
--- a/ompi/mpi/fortran/mpif-h/session_get_pset_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_get_pset_info_f.c
@@ -33,7 +33,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_GET_PSET_INFO = ompi_session_get_pset_info_f
 #pragma weak pmpi_session_get_pset_info = ompi_session_get_pset_info_f
 #pragma weak pmpi_session_get_pset_info_ = ompi_session_get_pset_info_f
@@ -52,7 +52,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_GET_PSET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_GET_PSET_INFO = ompi_session_get_pset_info_f
 #pragma weak mpi_session_get_pset_info = ompi_session_get_pset_info_f
 #pragma weak mpi_session_get_pset_info_ = ompi_session_get_pset_info_f
diff --git a/ompi/mpi/fortran/mpif-h/session_iflush_buffer_f.c b/ompi/mpi/fortran/mpif-h/session_iflush_buffer_f.c
index 2ad8d8b6f3b..0294685a235 100644
--- a/ompi/mpi/fortran/mpif-h/session_iflush_buffer_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_iflush_buffer_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_IFLUSH_BUFFER = ompi_session_iflush_buffer_f
 #pragma weak pmpi_session_iflush_buffer = ompi_session_iflush_buffer_f
 #pragma weak pmpi_session_iflush_buffer_ = ompi_session_iflush_buffer_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_IFLUSH_BUFFER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_IFLUSH_BUFFER = ompi_session_iflush_buffer_f
 #pragma weak mpi_session_iflush_buffer = ompi_session_iflush_buffer_f
 #pragma weak mpi_session_iflush_buffer_ = ompi_session_iflush_buffer_f
diff --git a/ompi/mpi/fortran/mpif-h/session_init_f.c b/ompi/mpi/fortran/mpif-h/session_init_f.c
index b36a324f09d..8abd84cefc7 100644
--- a/ompi/mpi/fortran/mpif-h/session_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_init_f.c
@@ -29,7 +29,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_INIT = ompi_session_init_f
 #pragma weak pmpi_session_init = ompi_session_init_f
 #pragma weak pmpi_session_init_ = ompi_session_init_f
@@ -48,7 +48,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_INIT = ompi_session_init_f
 #pragma weak mpi_session_init = ompi_session_init_f
 #pragma weak mpi_session_init_ = ompi_session_init_f
diff --git a/ompi/mpi/fortran/mpif-h/session_set_errhandler_f.c b/ompi/mpi/fortran/mpif-h/session_set_errhandler_f.c
index e90a2895063..63acb1bb2e3 100644
--- a/ompi/mpi/fortran/mpif-h/session_set_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/session_set_errhandler_f.c
@@ -27,7 +27,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SESSION_SET_ERRHANDLER = ompi_session_set_errhandler_f
 #pragma weak pmpi_session_set_errhandler = ompi_session_set_errhandler_f
 #pragma weak pmpi_session_set_errhandler_ = ompi_session_set_errhandler_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SESSION_SET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SESSION_SET_ERRHANDLER = ompi_session_set_errhandler_f
 #pragma weak mpi_session_set_errhandler = ompi_session_set_errhandler_f
 #pragma weak mpi_session_set_errhandler_ = ompi_session_set_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/ssend_f.c b/ompi/mpi/fortran/mpif-h/ssend_f.c
index 4ba3e8d7744..5efc5611ad1 100644
--- a/ompi/mpi/fortran/mpif-h/ssend_f.c
+++ b/ompi/mpi/fortran/mpif-h/ssend_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SSEND = ompi_ssend_f
 #pragma weak pmpi_ssend = ompi_ssend_f
 #pragma weak pmpi_ssend_ = ompi_ssend_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SSEND,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SSEND = ompi_ssend_f
 #pragma weak mpi_ssend = ompi_ssend_f
 #pragma weak mpi_ssend_ = ompi_ssend_f
diff --git a/ompi/mpi/fortran/mpif-h/ssend_init_f.c b/ompi/mpi/fortran/mpif-h/ssend_init_f.c
index 62e2d8bb027..1844ac88e79 100644
--- a/ompi/mpi/fortran/mpif-h/ssend_init_f.c
+++ b/ompi/mpi/fortran/mpif-h/ssend_init_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_SSEND_INIT = ompi_ssend_init_f
 #pragma weak pmpi_ssend_init = ompi_ssend_init_f
 #pragma weak pmpi_ssend_init_ = ompi_ssend_init_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_SSEND_INIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_SSEND_INIT = ompi_ssend_init_f
 #pragma weak mpi_ssend_init = ompi_ssend_init_f
 #pragma weak mpi_ssend_init_ = ompi_ssend_init_f
diff --git a/ompi/mpi/fortran/mpif-h/start_f.c b/ompi/mpi/fortran/mpif-h/start_f.c
index fb1c1a47988..70c2833b3bf 100644
--- a/ompi/mpi/fortran/mpif-h/start_f.c
+++ b/ompi/mpi/fortran/mpif-h/start_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_START = ompi_start_f
 #pragma weak pmpi_start = ompi_start_f
 #pragma weak pmpi_start_ = ompi_start_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_START,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_START = ompi_start_f
 #pragma weak mpi_start = ompi_start_f
 #pragma weak mpi_start_ = ompi_start_f
diff --git a/ompi/mpi/fortran/mpif-h/startall_f.c b/ompi/mpi/fortran/mpif-h/startall_f.c
index 49abfc6642f..e97e8e3f5c2 100644
--- a/ompi/mpi/fortran/mpif-h/startall_f.c
+++ b/ompi/mpi/fortran/mpif-h/startall_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_STARTALL = ompi_startall_f
 #pragma weak pmpi_startall = ompi_startall_f
 #pragma weak pmpi_startall_ = ompi_startall_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_STARTALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_STARTALL = ompi_startall_f
 #pragma weak mpi_startall = ompi_startall_f
 #pragma weak mpi_startall_ = ompi_startall_f
diff --git a/ompi/mpi/fortran/mpif-h/status_f082f_f.c b/ompi/mpi/fortran/mpif-h/status_f082f_f.c
index 83ac4d56727..80b3eafd959 100644
--- a/ompi/mpi/fortran/mpif-h/status_f082f_f.c
+++ b/ompi/mpi/fortran/mpif-h/status_f082f_f.c
@@ -14,7 +14,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_STATUS_F082F = ompi_status_f082f_f
 #pragma weak pmpi_status_f082f = ompi_status_f082f_f
 #pragma weak pmpi_status_f082f_ = ompi_status_f082f_f
@@ -33,7 +33,7 @@ OMPI_GENERATE_F77_BINDINGS(PMPI_STATUS_F082F,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_STATUS_F082F = ompi_status_f082f_f
 #pragma weak mpi_status_f082f = ompi_status_f082f_f
 #pragma weak mpi_status_f082f_ = ompi_status_f082f_f
diff --git a/ompi/mpi/fortran/mpif-h/status_f2f08_f.c b/ompi/mpi/fortran/mpif-h/status_f2f08_f.c
index dee468f994e..338a82b5c4b 100644
--- a/ompi/mpi/fortran/mpif-h/status_f2f08_f.c
+++ b/ompi/mpi/fortran/mpif-h/status_f2f08_f.c
@@ -14,7 +14,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_STATUS_F2F08 = ompi_status_f2f08_f
 #pragma weak pmpi_status_f2f08 = ompi_status_f2f08_f
 #pragma weak pmpi_status_f2f08_ = ompi_status_f2f08_f
@@ -33,7 +33,7 @@ OMPI_GENERATE_F77_BINDINGS(PMPI_STATUS_F2F08,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_STATUS_F2F08 = ompi_status_f2f08_f
 #pragma weak mpi_status_f2f08 = ompi_status_f2f08_f
 #pragma weak mpi_status_f2f08_ = ompi_status_f2f08_f
diff --git a/ompi/mpi/fortran/mpif-h/status_get_error_f.c b/ompi/mpi/fortran/mpif-h/status_get_error_f.c
new file mode 100644
index 00000000000..3d2894d7fa6
--- /dev/null
+++ b/ompi/mpi/fortran/mpif-h/status_get_error_f.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "ompi/mpi/fortran/mpif-h/bindings.h"
+#include "ompi/mpi/fortran/base/constants.h"
+
+#if OMPI_BUILD_MPI_PROFILING
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak PMPI_STATUS_GET_ERROR = ompi_status_get_error_f
+#pragma weak pmpi_status_get_error = ompi_status_get_error_f
+#pragma weak pmpi_status_get_error_ = ompi_status_get_error_f
+#pragma weak pmpi_status_get_error__ = ompi_status_get_error_f
+
+#pragma weak PMPI_Status_get_error_f = ompi_status_get_error_f
+#pragma weak PMPI_Status_get_error_f08 = ompi_status_get_error_f
+#else
+OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_GET_ERROR,
+                           pmpi_status_get_error,
+                           pmpi_status_get_error_,
+                           pmpi_status_get_error__,
+                           pompi_status_get_error_f,
+                           (MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr),
+                           (status, err, ierr) )
+#endif
+#endif
+
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak MPI_STATUS_GET_ERROR = ompi_status_get_error_f
+#pragma weak mpi_status_get_error = ompi_status_get_error_f
+#pragma weak mpi_status_get_error_ = ompi_status_get_error_f
+#pragma weak mpi_status_get_error__ = ompi_status_get_error_f
+
+#pragma weak MPI_Status_get_error_f = ompi_status_get_error_f
+#pragma weak MPI_Status_get_error_f08 = ompi_status_get_error_f
+#else
+#if ! OMPI_BUILD_MPI_PROFILING
+OMPI_GENERATE_F77_BINDINGS (MPI_STATUS_GET_ERROR,
+                           mpi_status_get_error,
+                           mpi_status_get_error_,
+                           mpi_status_get_error__,
+                           ompi_status_get_error_f,
+                           (MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr),
+                           (status, err, ierr) )
+#else
+#define ompi_status_get_error_f pompi_status_get_error_f
+#endif
+#endif
+
+
+void ompi_status_get_error_f(MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr)
+{
+    int c_ierr;
+    MPI_Status c_status;
+    OMPI_SINGLE_NAME_DECL(err);
+
+    /* This seems silly, but someone will do it */
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        *err = OMPI_INT_2_FINT(0);
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = PMPI_Status_get_error(&c_status, OMPI_SINGLE_NAME_CONVERT(err));
+
+        if (MPI_SUCCESS == c_ierr) {
+            OMPI_SINGLE_INT_2_FINT(err);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/mpif-h/status_get_source_f.c b/ompi/mpi/fortran/mpif-h/status_get_source_f.c
new file mode 100644
index 00000000000..2b10c19f028
--- /dev/null
+++ b/ompi/mpi/fortran/mpif-h/status_get_source_f.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "ompi/mpi/fortran/mpif-h/bindings.h"
+#include "ompi/mpi/fortran/base/constants.h"
+
+#if OMPI_BUILD_MPI_PROFILING
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak PMPI_STATUS_GET_SOURCE = ompi_status_get_source_f
+#pragma weak pmpi_status_get_source = ompi_status_get_source_f
+#pragma weak pmpi_status_get_source_ = ompi_status_get_source_f
+#pragma weak pmpi_status_get_source__ = ompi_status_get_source_f
+
+#pragma weak PMPI_Status_get_source_f = ompi_status_get_source_f
+#pragma weak PMPI_Status_get_source_f08 = ompi_status_get_source_f
+#else
+OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_GET_SOURCE,
+                           pmpi_status_get_source,
+                           pmpi_status_get_source_,
+                           pmpi_status_get_source__,
+                           pompi_status_get_source_f,
+                           (MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr),
+                           (status, source, ierr) )
+#endif
+#endif
+
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak MPI_STATUS_GET_SOURCE = ompi_status_get_source_f
+#pragma weak mpi_status_get_source = ompi_status_get_source_f
+#pragma weak mpi_status_get_source_ = ompi_status_get_source_f
+#pragma weak mpi_status_get_source__ = ompi_status_get_source_f
+
+#pragma weak MPI_Status_get_source_f = ompi_status_get_source_f
+#pragma weak MPI_Status_get_source_f08 = ompi_status_get_source_f
+#else
+#if ! OMPI_BUILD_MPI_PROFILING
+OMPI_GENERATE_F77_BINDINGS (MPI_STATUS_GET_SOURCE,
+                           mpi_status_get_source,
+                           mpi_status_get_source_,
+                           mpi_status_get_source__,
+                           ompi_status_get_source_f,
+                           (MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr),
+                           (status, source, ierr) )
+#else
+#define ompi_status_get_source_f pompi_status_get_source_f
+#endif
+#endif
+
+
+void ompi_status_get_source_f(MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr)
+{
+    int c_ierr;
+    MPI_Status c_status;
+    OMPI_SINGLE_NAME_DECL(source);
+
+    /* This seems silly, but someone will do it */
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        *source = OMPI_INT_2_FINT(0);
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = PMPI_Status_get_source(&c_status, OMPI_SINGLE_NAME_CONVERT(source));
+
+        if (MPI_SUCCESS == c_ierr) {
+            OMPI_SINGLE_INT_2_FINT(source);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/mpif-h/status_get_tag_f.c b/ompi/mpi/fortran/mpif-h/status_get_tag_f.c
new file mode 100644
index 00000000000..9aaa078c5d9
--- /dev/null
+++ b/ompi/mpi/fortran/mpif-h/status_get_tag_f.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "ompi/mpi/fortran/mpif-h/bindings.h"
+#include "ompi/mpi/fortran/base/constants.h"
+
+#if OMPI_BUILD_MPI_PROFILING
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak PMPI_STATUS_GET_TAG = ompi_status_get_tag_f
+#pragma weak pmpi_status_get_tag = ompi_status_get_tag_f
+#pragma weak pmpi_status_get_tag_ = ompi_status_get_tag_f
+#pragma weak pmpi_status_get_tag__ = ompi_status_get_tag_f
+
+#pragma weak PMPI_Status_get_tag_f = ompi_status_get_tag_f
+#pragma weak PMPI_Status_get_tag_f08 = ompi_status_get_tag_f
+#else
+OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_GET_TAG,
+                           pmpi_status_get_tag,
+                           pmpi_status_get_tag_,
+                           pmpi_status_get_tag__,
+                           pompi_status_get_tag_f,
+                           (MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr),
+                           (status, tag, ierr) )
+#endif
+#endif
+
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak MPI_STATUS_GET_TAG = ompi_status_get_tag_f
+#pragma weak mpi_status_get_tag = ompi_status_get_tag_f
+#pragma weak mpi_status_get_tag_ = ompi_status_get_tag_f
+#pragma weak mpi_status_get_tag__ = ompi_status_get_tag_f
+
+#pragma weak MPI_Status_get_tag_f = ompi_status_get_tag_f
+#pragma weak MPI_Status_get_tag_f08 = ompi_status_get_tag_f
+#else
+#if ! OMPI_BUILD_MPI_PROFILING
+OMPI_GENERATE_F77_BINDINGS (MPI_STATUS_GET_TAG,
+                           mpi_status_get_tag,
+                           mpi_status_get_tag_,
+                           mpi_status_get_tag__,
+                           ompi_status_get_tag_f,
+                           (MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr),
+                           (status, tag, ierr) )
+#else
+#define ompi_status_get_tag_f pompi_status_get_tag_f
+#endif
+#endif
+
+
+void ompi_status_get_tag_f(MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr)
+{
+    int c_ierr;
+    MPI_Status c_status;
+    OMPI_SINGLE_NAME_DECL(tag);
+
+    /* This seems silly, but someone will do it */
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        *tag = OMPI_INT_2_FINT(0);
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = PMPI_Status_get_tag(&c_status, OMPI_SINGLE_NAME_CONVERT(tag));
+
+        if (MPI_SUCCESS == c_ierr) {
+            OMPI_SINGLE_INT_2_FINT(tag);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/mpif-h/status_set_cancelled_f.c b/ompi/mpi/fortran/mpif-h/status_set_cancelled_f.c
index 1c9fc45d4bc..1185450a122 100644
--- a/ompi/mpi/fortran/mpif-h/status_set_cancelled_f.c
+++ b/ompi/mpi/fortran/mpif-h/status_set_cancelled_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_STATUS_SET_CANCELLED = ompi_status_set_cancelled_f
 #pragma weak pmpi_status_set_cancelled = ompi_status_set_cancelled_f
 #pragma weak pmpi_status_set_cancelled_ = ompi_status_set_cancelled_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_SET_CANCELLED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_STATUS_SET_CANCELLED = ompi_status_set_cancelled_f
 #pragma weak mpi_status_set_cancelled = ompi_status_set_cancelled_f
 #pragma weak mpi_status_set_cancelled_ = ompi_status_set_cancelled_f
diff --git a/ompi/mpi/fortran/mpif-h/status_set_elements_f.c b/ompi/mpi/fortran/mpif-h/status_set_elements_f.c
index 2567bf98113..ad223947f5d 100644
--- a/ompi/mpi/fortran/mpif-h/status_set_elements_f.c
+++ b/ompi/mpi/fortran/mpif-h/status_set_elements_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_STATUS_SET_ELEMENTS = ompi_status_set_elements_f
 #pragma weak pmpi_status_set_elements = ompi_status_set_elements_f
 #pragma weak pmpi_status_set_elements_ = ompi_status_set_elements_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_SET_ELEMENTS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_STATUS_SET_ELEMENTS = ompi_status_set_elements_f
 #pragma weak mpi_status_set_elements = ompi_status_set_elements_f
 #pragma weak mpi_status_set_elements_ = ompi_status_set_elements_f
diff --git a/ompi/mpi/fortran/mpif-h/status_set_elements_x_f.c b/ompi/mpi/fortran/mpif-h/status_set_elements_x_f.c
index 255e68775e9..2221efafb61 100644
--- a/ompi/mpi/fortran/mpif-h/status_set_elements_x_f.c
+++ b/ompi/mpi/fortran/mpif-h/status_set_elements_x_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_STATUS_SET_ELEMENTS_X = ompi_status_set_elements_x_f
 #pragma weak pmpi_status_set_elements_x = ompi_status_set_elements_x_f
 #pragma weak pmpi_status_set_elements_x_ = ompi_status_set_elements_x_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_SET_ELEMENTS_X,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_STATUS_SET_ELEMENTS_X = ompi_status_set_elements_x_f
 #pragma weak mpi_status_set_elements_x = ompi_status_set_elements_x_f
 #pragma weak mpi_status_set_elements_x_ = ompi_status_set_elements_x_f
diff --git a/ompi/mpi/fortran/mpif-h/status_set_error_f.c b/ompi/mpi/fortran/mpif-h/status_set_error_f.c
new file mode 100644
index 00000000000..4398552205a
--- /dev/null
+++ b/ompi/mpi/fortran/mpif-h/status_set_error_f.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "ompi/mpi/fortran/mpif-h/bindings.h"
+#include "ompi/mpi/fortran/base/constants.h"
+
+#if OMPI_BUILD_MPI_PROFILING
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak PMPI_STATUS_SET_ERROR = ompi_status_set_error_f
+#pragma weak pmpi_status_set_error = ompi_status_set_error_f
+#pragma weak pmpi_status_set_error_ = ompi_status_set_error_f
+#pragma weak pmpi_status_set_error__ = ompi_status_set_error_f
+
+#pragma weak PMPI_Status_set_error_f = ompi_status_set_error_f
+#pragma weak PMPI_Status_set_error_f08 = ompi_status_set_error_f
+#else
+OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_SET_ERROR,
+                           pmpi_status_set_error,
+                           pmpi_status_set_error_,
+                           pmpi_status_set_error__,
+                           pompi_status_set_error_f,
+                           (MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr),
+                           (status, err, ierr) )
+#endif
+#endif
+
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak MPI_STATUS_SET_ERROR = ompi_status_set_error_f
+#pragma weak mpi_status_set_error = ompi_status_set_error_f
+#pragma weak mpi_status_set_error_ = ompi_status_set_error_f
+#pragma weak mpi_status_set_error__ = ompi_status_set_error_f
+
+#pragma weak MPI_Status_set_error_f = ompi_status_set_error_f
+#pragma weak MPI_Status_set_error_f08 = ompi_status_set_error_f
+#else
+#if ! OMPI_BUILD_MPI_PROFILING
+OMPI_GENERATE_F77_BINDINGS (MPI_STATUS_SET_ERROR,
+                           mpi_status_set_error,
+                           mpi_status_set_error_,
+                           mpi_status_set_error__,
+                           ompi_status_set_error_f,
+                           (MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr),
+                           (status, err, ierr) )
+#else
+#define ompi_status_set_error_f pompi_status_set_error_f
+#endif
+#endif
+
+
+void ompi_status_set_error_f(MPI_Fint *status, MPI_Fint *err, MPI_Fint *ierr)
+{
+    int c_ierr;
+    MPI_Status c_status;
+
+    /* This seems silly, but someone will do it */
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = PMPI_Status_set_error(&c_status, OMPI_FINT_2_INT(*err));
+
+        if (MPI_SUCCESS == c_ierr) {
+            PMPI_Status_c2f(&c_status, status);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/mpif-h/status_set_source_f.c b/ompi/mpi/fortran/mpif-h/status_set_source_f.c
new file mode 100644
index 00000000000..1c3e22d44e6
--- /dev/null
+++ b/ompi/mpi/fortran/mpif-h/status_set_source_f.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "ompi/mpi/fortran/mpif-h/bindings.h"
+#include "ompi/mpi/fortran/base/constants.h"
+
+#if OMPI_BUILD_MPI_PROFILING
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak PMPI_STATUS_SET_SOURCE = ompi_status_set_source_f
+#pragma weak pmpi_status_set_source = ompi_status_set_source_f
+#pragma weak pmpi_status_set_source_ = ompi_status_set_source_f
+#pragma weak pmpi_status_set_source__ = ompi_status_set_source_f
+
+#pragma weak PMPI_Status_set_source_f = ompi_status_set_source_f
+#pragma weak PMPI_Status_set_source_f08 = ompi_status_set_source_f
+#else
+OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_SET_SOURCE,
+                           pmpi_status_set_source,
+                           pmpi_status_set_source_,
+                           pmpi_status_set_source__,
+                           pompi_status_set_source_f,
+                           (MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr),
+                           (status, source, ierr) )
+#endif
+#endif
+
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak MPI_STATUS_SET_SOURCE = ompi_status_set_source_f
+#pragma weak mpi_status_set_source = ompi_status_set_source_f
+#pragma weak mpi_status_set_source_ = ompi_status_set_source_f
+#pragma weak mpi_status_set_source__ = ompi_status_set_source_f
+
+#pragma weak MPI_Status_set_source_f = ompi_status_set_source_f
+#pragma weak MPI_Status_set_source_f08 = ompi_status_set_source_f
+#else
+#if ! OMPI_BUILD_MPI_PROFILING
+OMPI_GENERATE_F77_BINDINGS (MPI_STATUS_SET_SOURCE,
+                           mpi_status_set_source,
+                           mpi_status_set_source_,
+                           mpi_status_set_source__,
+                           ompi_status_set_source_f,
+                           (MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr),
+                           (status, source, ierr) )
+#else
+#define ompi_status_set_source_f pompi_status_set_source_f
+#endif
+#endif
+
+
+void ompi_status_set_source_f(MPI_Fint *status, MPI_Fint *source, MPI_Fint *ierr)
+{
+    int c_ierr;
+    MPI_Status c_status;
+
+    /* This seems silly, but someone will do it */
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = PMPI_Status_set_source(&c_status, OMPI_FINT_2_INT(*source));
+
+        if (MPI_SUCCESS == c_ierr) {
+            PMPI_Status_c2f(&c_status, status);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/mpif-h/status_set_tag_f.c b/ompi/mpi/fortran/mpif-h/status_set_tag_f.c
new file mode 100644
index 00000000000..081bf3d0e34
--- /dev/null
+++ b/ompi/mpi/fortran/mpif-h/status_set_tag_f.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Triad National Security, LLC.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+
+#include "ompi/mpi/fortran/mpif-h/bindings.h"
+#include "ompi/mpi/fortran/base/constants.h"
+
+#if OMPI_BUILD_MPI_PROFILING
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak PMPI_STATUS_SET_TAG = ompi_status_set_tag_f
+#pragma weak pmpi_status_set_tag = ompi_status_set_tag_f
+#pragma weak pmpi_status_set_tag_ = ompi_status_set_tag_f
+#pragma weak pmpi_status_set_tag__ = ompi_status_set_tag_f
+
+#pragma weak PMPI_Status_set_tag_f = ompi_status_set_tag_f
+#pragma weak PMPI_Status_set_tag_f08 = ompi_status_set_tag_f
+#else
+OMPI_GENERATE_F77_BINDINGS (PMPI_STATUS_SET_TAG,
+                           pmpi_status_set_tag,
+                           pmpi_status_set_tag_,
+                           pmpi_status_set_tag__,
+                           pompi_status_set_tag_f,
+                           (MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr),
+                           (status, tag, ierr) )
+#endif
+#endif
+
+#if OPAL_HAVE_WEAK_ALIASES
+#pragma weak MPI_STATUS_SET_TAG = ompi_status_set_tag_f
+#pragma weak mpi_status_set_tag = ompi_status_set_tag_f
+#pragma weak mpi_status_set_tag_ = ompi_status_set_tag_f
+#pragma weak mpi_status_set_tag__ = ompi_status_set_tag_f
+
+#pragma weak MPI_Status_set_tag_f = ompi_status_set_tag_f
+#pragma weak MPI_Status_set_tag_f08 = ompi_status_set_tag_f
+#else
+#if ! OMPI_BUILD_MPI_PROFILING
+OMPI_GENERATE_F77_BINDINGS (MPI_STATUS_SET_TAG,
+                           mpi_status_set_tag,
+                           mpi_status_set_tag_,
+                           mpi_status_set_tag__,
+                           ompi_status_set_tag_f,
+                           (MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr),
+                           (status, tag, ierr) )
+#else
+#define ompi_status_set_tag_f pompi_status_set_tag_f
+#endif
+#endif
+
+
+void ompi_status_set_tag_f(MPI_Fint *status, MPI_Fint *tag, MPI_Fint *ierr)
+{
+    int c_ierr;
+    MPI_Status c_status;
+
+    /* This seems silly, but someone will do it */
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = PMPI_Status_set_tag(&c_status, OMPI_FINT_2_INT(*tag));
+
+        if (MPI_SUCCESS == c_ierr) {
+            PMPI_Status_c2f(&c_status, status);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/mpif-h/test_cancelled_f.c b/ompi/mpi/fortran/mpif-h/test_cancelled_f.c
index caf371ecd97..586a2017b97 100644
--- a/ompi/mpi/fortran/mpif-h/test_cancelled_f.c
+++ b/ompi/mpi/fortran/mpif-h/test_cancelled_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TEST_CANCELLED = ompi_test_cancelled_f
 #pragma weak pmpi_test_cancelled = ompi_test_cancelled_f
 #pragma weak pmpi_test_cancelled_ = ompi_test_cancelled_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TEST_CANCELLED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TEST_CANCELLED = ompi_test_cancelled_f
 #pragma weak mpi_test_cancelled = ompi_test_cancelled_f
 #pragma weak mpi_test_cancelled_ = ompi_test_cancelled_f
diff --git a/ompi/mpi/fortran/mpif-h/test_f.c b/ompi/mpi/fortran/mpif-h/test_f.c
index f92e1d219fc..5701496ba8b 100644
--- a/ompi/mpi/fortran/mpif-h/test_f.c
+++ b/ompi/mpi/fortran/mpif-h/test_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TEST = ompi_test_f
 #pragma weak pmpi_test = ompi_test_f
 #pragma weak pmpi_test_ = ompi_test_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TEST,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TEST = ompi_test_f
 #pragma weak mpi_test = ompi_test_f
 #pragma weak mpi_test_ = ompi_test_f
diff --git a/ompi/mpi/fortran/mpif-h/testall_f.c b/ompi/mpi/fortran/mpif-h/testall_f.c
index 57121f098b1..1265aa950bf 100644
--- a/ompi/mpi/fortran/mpif-h/testall_f.c
+++ b/ompi/mpi/fortran/mpif-h/testall_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TESTALL = ompi_testall_f
 #pragma weak pmpi_testall = ompi_testall_f
 #pragma weak pmpi_testall_ = ompi_testall_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TESTALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TESTALL = ompi_testall_f
 #pragma weak mpi_testall = ompi_testall_f
 #pragma weak mpi_testall_ = ompi_testall_f
diff --git a/ompi/mpi/fortran/mpif-h/testany_f.c b/ompi/mpi/fortran/mpif-h/testany_f.c
index df46332d106..ba4b3d321a5 100644
--- a/ompi/mpi/fortran/mpif-h/testany_f.c
+++ b/ompi/mpi/fortran/mpif-h/testany_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TESTANY = ompi_testany_f
 #pragma weak pmpi_testany = ompi_testany_f
 #pragma weak pmpi_testany_ = ompi_testany_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TESTANY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TESTANY = ompi_testany_f
 #pragma weak mpi_testany = ompi_testany_f
 #pragma weak mpi_testany_ = ompi_testany_f
diff --git a/ompi/mpi/fortran/mpif-h/testsome_f.c b/ompi/mpi/fortran/mpif-h/testsome_f.c
index 9e95bceb1c1..54c61e0164c 100644
--- a/ompi/mpi/fortran/mpif-h/testsome_f.c
+++ b/ompi/mpi/fortran/mpif-h/testsome_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TESTSOME = ompi_testsome_f
 #pragma weak pmpi_testsome = ompi_testsome_f
 #pragma weak pmpi_testsome_ = ompi_testsome_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TESTSOME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TESTSOME = ompi_testsome_f
 #pragma weak mpi_testsome = ompi_testsome_f
 #pragma weak mpi_testsome_ = ompi_testsome_f
diff --git a/ompi/mpi/fortran/mpif-h/topo_test_f.c b/ompi/mpi/fortran/mpif-h/topo_test_f.c
index 82789a60abf..3735edfb7c7 100644
--- a/ompi/mpi/fortran/mpif-h/topo_test_f.c
+++ b/ompi/mpi/fortran/mpif-h/topo_test_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TOPO_TEST = ompi_topo_test_f
 #pragma weak pmpi_topo_test = ompi_topo_test_f
 #pragma weak pmpi_topo_test_ = ompi_topo_test_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TOPO_TEST,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TOPO_TEST = ompi_topo_test_f
 #pragma weak mpi_topo_test = ompi_topo_test_f
 #pragma weak mpi_topo_test_ = ompi_topo_test_f
diff --git a/ompi/mpi/fortran/mpif-h/type_commit_f.c b/ompi/mpi/fortran/mpif-h/type_commit_f.c
index 129c80a7b6e..739e1bc75a2 100644
--- a/ompi/mpi/fortran/mpif-h/type_commit_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_commit_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_COMMIT = ompi_type_commit_f
 #pragma weak pmpi_type_commit = ompi_type_commit_f
 #pragma weak pmpi_type_commit_ = ompi_type_commit_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_COMMIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_COMMIT = ompi_type_commit_f
 #pragma weak mpi_type_commit = ompi_type_commit_f
 #pragma weak mpi_type_commit_ = ompi_type_commit_f
diff --git a/ompi/mpi/fortran/mpif-h/type_contiguous_f.c b/ompi/mpi/fortran/mpif-h/type_contiguous_f.c
index 42ffd8fa900..29757fdd400 100644
--- a/ompi/mpi/fortran/mpif-h/type_contiguous_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_contiguous_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CONTIGUOUS = ompi_type_contiguous_f
 #pragma weak pmpi_type_contiguous = ompi_type_contiguous_f
 #pragma weak pmpi_type_contiguous_ = ompi_type_contiguous_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CONTIGUOUS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CONTIGUOUS = ompi_type_contiguous_f
 #pragma weak mpi_type_contiguous = ompi_type_contiguous_f
 #pragma weak mpi_type_contiguous_ = ompi_type_contiguous_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_darray_f.c b/ompi/mpi/fortran/mpif-h/type_create_darray_f.c
index c6711c355ee..b0224d6d2ba 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_darray_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_darray_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_DARRAY = ompi_type_create_darray_f
 #pragma weak pmpi_type_create_darray = ompi_type_create_darray_f
 #pragma weak pmpi_type_create_darray_ = ompi_type_create_darray_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_DARRAY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_DARRAY = ompi_type_create_darray_f
 #pragma weak mpi_type_create_darray = ompi_type_create_darray_f
 #pragma weak mpi_type_create_darray_ = ompi_type_create_darray_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_f90_complex_f.c b/ompi/mpi/fortran/mpif-h/type_create_f90_complex_f.c
index df9c8c8e033..aaa16b59984 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_f90_complex_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_f90_complex_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_F90_COMPLEX = ompi_type_create_f90_complex_f
 #pragma weak pmpi_type_create_f90_complex = ompi_type_create_f90_complex_f
 #pragma weak pmpi_type_create_f90_complex_ = ompi_type_create_f90_complex_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_F90_COMPLEX,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_F90_COMPLEX = ompi_type_create_f90_complex_f
 #pragma weak mpi_type_create_f90_complex = ompi_type_create_f90_complex_f
 #pragma weak mpi_type_create_f90_complex_ = ompi_type_create_f90_complex_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_f90_integer_f.c b/ompi/mpi/fortran/mpif-h/type_create_f90_integer_f.c
index 385e9bd2f28..94cb25c5dde 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_f90_integer_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_f90_integer_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_F90_INTEGER = ompi_type_create_f90_integer_f
 #pragma weak pmpi_type_create_f90_integer = ompi_type_create_f90_integer_f
 #pragma weak pmpi_type_create_f90_integer_ = ompi_type_create_f90_integer_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_F90_INTEGER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_F90_INTEGER = ompi_type_create_f90_integer_f
 #pragma weak mpi_type_create_f90_integer = ompi_type_create_f90_integer_f
 #pragma weak mpi_type_create_f90_integer_ = ompi_type_create_f90_integer_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_f90_real_f.c b/ompi/mpi/fortran/mpif-h/type_create_f90_real_f.c
index 949afed45bf..a64807b4065 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_f90_real_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_f90_real_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_F90_REAL = ompi_type_create_f90_real_f
 #pragma weak pmpi_type_create_f90_real = ompi_type_create_f90_real_f
 #pragma weak pmpi_type_create_f90_real_ = ompi_type_create_f90_real_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_F90_REAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_F90_REAL = ompi_type_create_f90_real_f
 #pragma weak mpi_type_create_f90_real = ompi_type_create_f90_real_f
 #pragma weak mpi_type_create_f90_real_ = ompi_type_create_f90_real_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_hindexed_block_f.c b/ompi/mpi/fortran/mpif-h/type_create_hindexed_block_f.c
index 111344c9247..96d7b18330d 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_hindexed_block_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_hindexed_block_f.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_HINDEXED_BLOCK = ompi_type_create_hindexed_block_f
 #pragma weak pmpi_type_create_hindexed_block = ompi_type_create_hindexed_block_f
 #pragma weak pmpi_type_create_hindexed_block_ = ompi_type_create_hindexed_block_f
@@ -36,7 +36,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_HINDEXED_BLOCK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_HINDEXED_BLOCK = ompi_type_create_hindexed_block_f
 #pragma weak mpi_type_create_hindexed_block = ompi_type_create_hindexed_block_f
 #pragma weak mpi_type_create_hindexed_block_ = ompi_type_create_hindexed_block_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_hindexed_f.c b/ompi/mpi/fortran/mpif-h/type_create_hindexed_f.c
index 416764943d7..2326cbe3dce 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_hindexed_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_hindexed_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_HINDEXED = ompi_type_create_hindexed_f
 #pragma weak pmpi_type_create_hindexed = ompi_type_create_hindexed_f
 #pragma weak pmpi_type_create_hindexed_ = ompi_type_create_hindexed_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_HINDEXED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_HINDEXED = ompi_type_create_hindexed_f
 #pragma weak mpi_type_create_hindexed = ompi_type_create_hindexed_f
 #pragma weak mpi_type_create_hindexed_ = ompi_type_create_hindexed_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_hvector_f.c b/ompi/mpi/fortran/mpif-h/type_create_hvector_f.c
index aff809c6976..19043dc60bf 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_hvector_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_hvector_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_HVECTOR = ompi_type_create_hvector_f
 #pragma weak pmpi_type_create_hvector = ompi_type_create_hvector_f
 #pragma weak pmpi_type_create_hvector_ = ompi_type_create_hvector_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_HVECTOR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_HVECTOR = ompi_type_create_hvector_f
 #pragma weak mpi_type_create_hvector = ompi_type_create_hvector_f
 #pragma weak mpi_type_create_hvector_ = ompi_type_create_hvector_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_indexed_block_f.c b/ompi/mpi/fortran/mpif-h/type_create_indexed_block_f.c
index 5df675820d7..623c320cac7 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_indexed_block_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_indexed_block_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_INDEXED_BLOCK = ompi_type_create_indexed_block_f
 #pragma weak pmpi_type_create_indexed_block = ompi_type_create_indexed_block_f
 #pragma weak pmpi_type_create_indexed_block_ = ompi_type_create_indexed_block_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_INDEXED_BLOCK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_INDEXED_BLOCK = ompi_type_create_indexed_block_f
 #pragma weak mpi_type_create_indexed_block = ompi_type_create_indexed_block_f
 #pragma weak mpi_type_create_indexed_block_ = ompi_type_create_indexed_block_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_keyval_f.c b/ompi/mpi/fortran/mpif-h/type_create_keyval_f.c
index 22074a8d93f..7149e583e2d 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_keyval_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_keyval_f.c
@@ -25,7 +25,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_KEYVAL = ompi_type_create_keyval_f
 #pragma weak pmpi_type_create_keyval = ompi_type_create_keyval_f
 #pragma weak pmpi_type_create_keyval_ = ompi_type_create_keyval_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS(PMPI_TYPE_CREATE_KEYVAL, pmpi_type_create_keyval,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_KEYVAL = ompi_type_create_keyval_f
 #pragma weak mpi_type_create_keyval = ompi_type_create_keyval_f
 #pragma weak mpi_type_create_keyval_ = ompi_type_create_keyval_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_resized_f.c b/ompi/mpi/fortran/mpif-h/type_create_resized_f.c
index 7bb66b1cc6e..07356276525 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_resized_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_resized_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_RESIZED = ompi_type_create_resized_f
 #pragma weak pmpi_type_create_resized = ompi_type_create_resized_f
 #pragma weak pmpi_type_create_resized_ = ompi_type_create_resized_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_RESIZED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_RESIZED = ompi_type_create_resized_f
 #pragma weak mpi_type_create_resized = ompi_type_create_resized_f
 #pragma weak mpi_type_create_resized_ = ompi_type_create_resized_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_struct_f.c b/ompi/mpi/fortran/mpif-h/type_create_struct_f.c
index 4e2ee89398a..80db6aedd56 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_struct_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_struct_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_STRUCT = ompi_type_create_struct_f
 #pragma weak pmpi_type_create_struct = ompi_type_create_struct_f
 #pragma weak pmpi_type_create_struct_ = ompi_type_create_struct_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_STRUCT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_STRUCT = ompi_type_create_struct_f
 #pragma weak mpi_type_create_struct = ompi_type_create_struct_f
 #pragma weak mpi_type_create_struct_ = ompi_type_create_struct_f
diff --git a/ompi/mpi/fortran/mpif-h/type_create_subarray_f.c b/ompi/mpi/fortran/mpif-h/type_create_subarray_f.c
index a4143ca24d0..a5aa6fd71d6 100644
--- a/ompi/mpi/fortran/mpif-h/type_create_subarray_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_create_subarray_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_CREATE_SUBARRAY = ompi_type_create_subarray_f
 #pragma weak pmpi_type_create_subarray = ompi_type_create_subarray_f
 #pragma weak pmpi_type_create_subarray_ = ompi_type_create_subarray_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_CREATE_SUBARRAY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_CREATE_SUBARRAY = ompi_type_create_subarray_f
 #pragma weak mpi_type_create_subarray = ompi_type_create_subarray_f
 #pragma weak mpi_type_create_subarray_ = ompi_type_create_subarray_f
diff --git a/ompi/mpi/fortran/mpif-h/type_delete_attr_f.c b/ompi/mpi/fortran/mpif-h/type_delete_attr_f.c
index 96756cdd568..c7d88f9f642 100644
--- a/ompi/mpi/fortran/mpif-h/type_delete_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_delete_attr_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_DELETE_ATTR = ompi_type_delete_attr_f
 #pragma weak pmpi_type_delete_attr = ompi_type_delete_attr_f
 #pragma weak pmpi_type_delete_attr_ = ompi_type_delete_attr_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_DELETE_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_DELETE_ATTR = ompi_type_delete_attr_f
 #pragma weak mpi_type_delete_attr = ompi_type_delete_attr_f
 #pragma weak mpi_type_delete_attr_ = ompi_type_delete_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/type_dup_f.c b/ompi/mpi/fortran/mpif-h/type_dup_f.c
index 42351e9f2a9..d9a1ba63efe 100644
--- a/ompi/mpi/fortran/mpif-h/type_dup_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_dup_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_DUP = ompi_type_dup_f
 #pragma weak pmpi_type_dup = ompi_type_dup_f
 #pragma weak pmpi_type_dup_ = ompi_type_dup_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_DUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_DUP = ompi_type_dup_f
 #pragma weak mpi_type_dup = ompi_type_dup_f
 #pragma weak mpi_type_dup_ = ompi_type_dup_f
diff --git a/ompi/mpi/fortran/mpif-h/type_extent_f.c b/ompi/mpi/fortran/mpif-h/type_extent_f.c
index a2baf215a6b..8cb6a2c3b77 100644
--- a/ompi/mpi/fortran/mpif-h/type_extent_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_extent_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_EXTENT = ompi_type_extent_f
 #pragma weak pmpi_type_extent = ompi_type_extent_f
 #pragma weak pmpi_type_extent_ = ompi_type_extent_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_EXTENT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_EXTENT = ompi_type_extent_f
 #pragma weak mpi_type_extent = ompi_type_extent_f
 #pragma weak mpi_type_extent_ = ompi_type_extent_f
diff --git a/ompi/mpi/fortran/mpif-h/type_free_f.c b/ompi/mpi/fortran/mpif-h/type_free_f.c
index bdee31aa0cd..1af092eabda 100644
--- a/ompi/mpi/fortran/mpif-h/type_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_FREE = ompi_type_free_f
 #pragma weak pmpi_type_free = ompi_type_free_f
 #pragma weak pmpi_type_free_ = ompi_type_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_FREE = ompi_type_free_f
 #pragma weak mpi_type_free = ompi_type_free_f
 #pragma weak mpi_type_free_ = ompi_type_free_f
diff --git a/ompi/mpi/fortran/mpif-h/type_free_keyval_f.c b/ompi/mpi/fortran/mpif-h/type_free_keyval_f.c
index 257b59abc01..1f0b1545153 100644
--- a/ompi/mpi/fortran/mpif-h/type_free_keyval_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_free_keyval_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_FREE_KEYVAL = ompi_type_free_keyval_f
 #pragma weak pmpi_type_free_keyval = ompi_type_free_keyval_f
 #pragma weak pmpi_type_free_keyval_ = ompi_type_free_keyval_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_FREE_KEYVAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_FREE_KEYVAL = ompi_type_free_keyval_f
 #pragma weak mpi_type_free_keyval = ompi_type_free_keyval_f
 #pragma weak mpi_type_free_keyval_ = ompi_type_free_keyval_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_attr_f.c b/ompi/mpi/fortran/mpif-h/type_get_attr_f.c
index 7b8dc979c91..f9e6a4783bb 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_attr_f.c
@@ -26,7 +26,7 @@
 #include "ompi/datatype/ompi_datatype.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_ATTR = ompi_type_get_attr_f
 #pragma weak pmpi_type_get_attr = ompi_type_get_attr_f
 #pragma weak pmpi_type_get_attr_ = ompi_type_get_attr_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_ATTR = ompi_type_get_attr_f
 #pragma weak mpi_type_get_attr = ompi_type_get_attr_f
 #pragma weak mpi_type_get_attr_ = ompi_type_get_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_contents_f.c b/ompi/mpi/fortran/mpif-h/type_get_contents_f.c
index b66323070d9..3d52dc144f6 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_contents_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_contents_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_CONTENTS = ompi_type_get_contents_f
 #pragma weak pmpi_type_get_contents = ompi_type_get_contents_f
 #pragma weak pmpi_type_get_contents_ = ompi_type_get_contents_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_CONTENTS,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_CONTENTS = ompi_type_get_contents_f
 #pragma weak mpi_type_get_contents = ompi_type_get_contents_f
 #pragma weak mpi_type_get_contents_ = ompi_type_get_contents_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_envelope_f.c b/ompi/mpi/fortran/mpif-h/type_get_envelope_f.c
index 23a2246dab4..7809b6648c9 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_envelope_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_envelope_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_ENVELOPE = ompi_type_get_envelope_f
 #pragma weak pmpi_type_get_envelope = ompi_type_get_envelope_f
 #pragma weak pmpi_type_get_envelope_ = ompi_type_get_envelope_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_ENVELOPE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_ENVELOPE = ompi_type_get_envelope_f
 #pragma weak mpi_type_get_envelope = ompi_type_get_envelope_f
 #pragma weak mpi_type_get_envelope_ = ompi_type_get_envelope_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_extent_f.c b/ompi/mpi/fortran/mpif-h/type_get_extent_f.c
index 24cd75f5da1..91ae9e07619 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_extent_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_extent_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_EXTENT = ompi_type_get_extent_f
 #pragma weak pmpi_type_get_extent = ompi_type_get_extent_f
 #pragma weak pmpi_type_get_extent_ = ompi_type_get_extent_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_EXTENT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_EXTENT = ompi_type_get_extent_f
 #pragma weak mpi_type_get_extent = ompi_type_get_extent_f
 #pragma weak mpi_type_get_extent_ = ompi_type_get_extent_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_extent_x_f.c b/ompi/mpi/fortran/mpif-h/type_get_extent_x_f.c
index dfd4d6755fe..877af0e14bb 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_extent_x_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_extent_x_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_EXTENT_X = ompi_type_get_extent_x_f
 #pragma weak pmpi_type_get_extent_x = ompi_type_get_extent_x_f
 #pragma weak pmpi_type_get_extent_x_ = ompi_type_get_extent_x_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_EXTENT_X,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_EXTENT_X = ompi_type_get_extent_x_f
 #pragma weak mpi_type_get_extent_x = ompi_type_get_extent_x_f
 #pragma weak mpi_type_get_extent_x_ = ompi_type_get_extent_x_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_name_f.c b/ompi/mpi/fortran/mpif-h/type_get_name_f.c
index 76ce7605843..300c3ac013f 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_name_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_NAME = ompi_type_get_name_f
 #pragma weak pmpi_type_get_name = ompi_type_get_name_f
 #pragma weak pmpi_type_get_name_ = ompi_type_get_name_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_NAME = ompi_type_get_name_f
 #pragma weak mpi_type_get_name = ompi_type_get_name_f
 #pragma weak mpi_type_get_name_ = ompi_type_get_name_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_true_extent_f.c b/ompi/mpi/fortran/mpif-h/type_get_true_extent_f.c
index 8ea8b81cbf4..2f395d9b7bf 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_true_extent_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_true_extent_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_TRUE_EXTENT = ompi_type_get_true_extent_f
 #pragma weak pmpi_type_get_true_extent = ompi_type_get_true_extent_f
 #pragma weak pmpi_type_get_true_extent_ = ompi_type_get_true_extent_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_TRUE_EXTENT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_TRUE_EXTENT = ompi_type_get_true_extent_f
 #pragma weak mpi_type_get_true_extent = ompi_type_get_true_extent_f
 #pragma weak mpi_type_get_true_extent_ = ompi_type_get_true_extent_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_true_extent_x_f.c b/ompi/mpi/fortran/mpif-h/type_get_true_extent_x_f.c
index cef713ff4a5..9ca49711738 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_true_extent_x_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_true_extent_x_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_TRUE_EXTENT_X = ompi_type_get_true_extent_x_f
 #pragma weak pmpi_type_get_true_extent_x = ompi_type_get_true_extent_x_f
 #pragma weak pmpi_type_get_true_extent_x_ = ompi_type_get_true_extent_x_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_TRUE_EXTENT_X,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_TRUE_EXTENT_X = ompi_type_get_true_extent_x_f
 #pragma weak mpi_type_get_true_extent_x = ompi_type_get_true_extent_x_f
 #pragma weak mpi_type_get_true_extent_x_ = ompi_type_get_true_extent_x_f
diff --git a/ompi/mpi/fortran/mpif-h/type_get_value_index_f.c b/ompi/mpi/fortran/mpif-h/type_get_value_index_f.c
index 8ac23331e60..0610877d377 100644
--- a/ompi/mpi/fortran/mpif-h/type_get_value_index_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_get_value_index_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_GET_VALUE_INDEX = ompi_type_get_value_index_f
 #pragma weak pmpi_type_get_value_index = ompi_type_get_value_index_f
 #pragma weak pmpi_type_get_value_index_ = ompi_type_get_value_index_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_GET_VALUE_INDEX,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_GET_VALUE_INDEX = ompi_type_get_value_index_f
 #pragma weak mpi_type_get_value_index = ompi_type_get_value_index_f
 #pragma weak mpi_type_get_value_index_ = ompi_type_get_value_index_f
diff --git a/ompi/mpi/fortran/mpif-h/type_hindexed_f.c b/ompi/mpi/fortran/mpif-h/type_hindexed_f.c
index 07c7af99fbb..a76ccc0b11b 100644
--- a/ompi/mpi/fortran/mpif-h/type_hindexed_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_hindexed_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_HINDEXED = ompi_type_hindexed_f
 #pragma weak pmpi_type_hindexed = ompi_type_hindexed_f
 #pragma weak pmpi_type_hindexed_ = ompi_type_hindexed_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_HINDEXED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_HINDEXED = ompi_type_hindexed_f
 #pragma weak mpi_type_hindexed = ompi_type_hindexed_f
 #pragma weak mpi_type_hindexed_ = ompi_type_hindexed_f
diff --git a/ompi/mpi/fortran/mpif-h/type_hvector_f.c b/ompi/mpi/fortran/mpif-h/type_hvector_f.c
index 1bc5720e9bb..450e256d54b 100644
--- a/ompi/mpi/fortran/mpif-h/type_hvector_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_hvector_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_HVECTOR = ompi_type_hvector_f
 #pragma weak pmpi_type_hvector = ompi_type_hvector_f
 #pragma weak pmpi_type_hvector_ = ompi_type_hvector_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_HVECTOR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_HVECTOR = ompi_type_hvector_f
 #pragma weak mpi_type_hvector = ompi_type_hvector_f
 #pragma weak mpi_type_hvector_ = ompi_type_hvector_f
diff --git a/ompi/mpi/fortran/mpif-h/type_indexed_f.c b/ompi/mpi/fortran/mpif-h/type_indexed_f.c
index f7b2b5fa1b7..3a88eba6f46 100644
--- a/ompi/mpi/fortran/mpif-h/type_indexed_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_indexed_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_INDEXED = ompi_type_indexed_f
 #pragma weak pmpi_type_indexed = ompi_type_indexed_f
 #pragma weak pmpi_type_indexed_ = ompi_type_indexed_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_INDEXED,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_INDEXED = ompi_type_indexed_f
 #pragma weak mpi_type_indexed = ompi_type_indexed_f
 #pragma weak mpi_type_indexed_ = ompi_type_indexed_f
diff --git a/ompi/mpi/fortran/mpif-h/type_lb_f.c b/ompi/mpi/fortran/mpif-h/type_lb_f.c
index 3867c35ad29..efa7e6aaf1f 100644
--- a/ompi/mpi/fortran/mpif-h/type_lb_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_lb_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_LB = ompi_type_lb_f
 #pragma weak pmpi_type_lb = ompi_type_lb_f
 #pragma weak pmpi_type_lb_ = ompi_type_lb_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_LB,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_LB = ompi_type_lb_f
 #pragma weak mpi_type_lb = ompi_type_lb_f
 #pragma weak mpi_type_lb_ = ompi_type_lb_f
diff --git a/ompi/mpi/fortran/mpif-h/type_match_size_f.c b/ompi/mpi/fortran/mpif-h/type_match_size_f.c
index e6b6b3388e7..73656db2492 100644
--- a/ompi/mpi/fortran/mpif-h/type_match_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_match_size_f.c
@@ -31,7 +31,7 @@
 #include "ompi/runtime/params.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_MATCH_SIZE = ompi_type_match_size_f
 #pragma weak pmpi_type_match_size = ompi_type_match_size_f
 #pragma weak pmpi_type_match_size_ = ompi_type_match_size_f
@@ -50,7 +50,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_MATCH_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_MATCH_SIZE = ompi_type_match_size_f
 #pragma weak mpi_type_match_size = ompi_type_match_size_f
 #pragma weak mpi_type_match_size_ = ompi_type_match_size_f
diff --git a/ompi/mpi/fortran/mpif-h/type_set_attr_f.c b/ompi/mpi/fortran/mpif-h/type_set_attr_f.c
index bc5c27d95f8..b134675ef4b 100644
--- a/ompi/mpi/fortran/mpif-h/type_set_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_set_attr_f.c
@@ -26,7 +26,7 @@
 #include "ompi/datatype/ompi_datatype.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_SET_ATTR = ompi_type_set_attr_f
 #pragma weak pmpi_type_set_attr = ompi_type_set_attr_f
 #pragma weak pmpi_type_set_attr_ = ompi_type_set_attr_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_SET_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_SET_ATTR = ompi_type_set_attr_f
 #pragma weak mpi_type_set_attr = ompi_type_set_attr_f
 #pragma weak mpi_type_set_attr_ = ompi_type_set_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/type_set_name_f.c b/ompi/mpi/fortran/mpif-h/type_set_name_f.c
index b2d8040af42..f7cf87bc683 100644
--- a/ompi/mpi/fortran/mpif-h/type_set_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_set_name_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_SET_NAME = ompi_type_set_name_f
 #pragma weak pmpi_type_set_name = ompi_type_set_name_f
 #pragma weak pmpi_type_set_name_ = ompi_type_set_name_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_SET_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_SET_NAME = ompi_type_set_name_f
 #pragma weak mpi_type_set_name = ompi_type_set_name_f
 #pragma weak mpi_type_set_name_ = ompi_type_set_name_f
diff --git a/ompi/mpi/fortran/mpif-h/type_size_f.c b/ompi/mpi/fortran/mpif-h/type_size_f.c
index e4bd0f862a6..ead390ab209 100644
--- a/ompi/mpi/fortran/mpif-h/type_size_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_size_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_SIZE = ompi_type_size_f
 #pragma weak pmpi_type_size = ompi_type_size_f
 #pragma weak pmpi_type_size_ = ompi_type_size_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_SIZE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_SIZE = ompi_type_size_f
 #pragma weak mpi_type_size = ompi_type_size_f
 #pragma weak mpi_type_size_ = ompi_type_size_f
diff --git a/ompi/mpi/fortran/mpif-h/type_size_x_f.c b/ompi/mpi/fortran/mpif-h/type_size_x_f.c
index eff61245d16..e84559b992a 100644
--- a/ompi/mpi/fortran/mpif-h/type_size_x_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_size_x_f.c
@@ -26,7 +26,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_SIZE_X = ompi_type_size_x_f
 #pragma weak pmpi_type_size_x = ompi_type_size_x_f
 #pragma weak pmpi_type_size_x_ = ompi_type_size_x_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_SIZE_X,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_SIZE_X = ompi_type_size_x_f
 #pragma weak mpi_type_size_x = ompi_type_size_x_f
 #pragma weak mpi_type_size_x_ = ompi_type_size_x_f
diff --git a/ompi/mpi/fortran/mpif-h/type_struct_f.c b/ompi/mpi/fortran/mpif-h/type_struct_f.c
index cf2a89ab1ea..298303d1c8b 100644
--- a/ompi/mpi/fortran/mpif-h/type_struct_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_struct_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_STRUCT = ompi_type_struct_f
 #pragma weak pmpi_type_struct = ompi_type_struct_f
 #pragma weak pmpi_type_struct_ = ompi_type_struct_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_STRUCT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_STRUCT = ompi_type_struct_f
 #pragma weak mpi_type_struct = ompi_type_struct_f
 #pragma weak mpi_type_struct_ = ompi_type_struct_f
diff --git a/ompi/mpi/fortran/mpif-h/type_ub_f.c b/ompi/mpi/fortran/mpif-h/type_ub_f.c
index 17a468a6343..538ecab89b1 100644
--- a/ompi/mpi/fortran/mpif-h/type_ub_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_ub_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_UB = ompi_type_ub_f
 #pragma weak pmpi_type_ub = ompi_type_ub_f
 #pragma weak pmpi_type_ub_ = ompi_type_ub_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_UB,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_UB = ompi_type_ub_f
 #pragma weak mpi_type_ub = ompi_type_ub_f
 #pragma weak mpi_type_ub_ = ompi_type_ub_f
diff --git a/ompi/mpi/fortran/mpif-h/type_vector_f.c b/ompi/mpi/fortran/mpif-h/type_vector_f.c
index 89650448eb9..debfca7562e 100644
--- a/ompi/mpi/fortran/mpif-h/type_vector_f.c
+++ b/ompi/mpi/fortran/mpif-h/type_vector_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_TYPE_VECTOR = ompi_type_vector_f
 #pragma weak pmpi_type_vector = ompi_type_vector_f
 #pragma weak pmpi_type_vector_ = ompi_type_vector_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_TYPE_VECTOR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_TYPE_VECTOR = ompi_type_vector_f
 #pragma weak mpi_type_vector = ompi_type_vector_f
 #pragma weak mpi_type_vector_ = ompi_type_vector_f
diff --git a/ompi/mpi/fortran/mpif-h/unpack_external_f.c b/ompi/mpi/fortran/mpif-h/unpack_external_f.c
index 4a64e1518da..8527c872697 100644
--- a/ompi/mpi/fortran/mpif-h/unpack_external_f.c
+++ b/ompi/mpi/fortran/mpif-h/unpack_external_f.c
@@ -28,7 +28,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_UNPACK_EXTERNAL = ompi_unpack_external_f
 #pragma weak pmpi_unpack_external = ompi_unpack_external_f
 #pragma weak pmpi_unpack_external_ = ompi_unpack_external_f
@@ -47,7 +47,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_UNPACK_EXTERNAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_UNPACK_EXTERNAL = ompi_unpack_external_f
 #pragma weak mpi_unpack_external = ompi_unpack_external_f
 #pragma weak mpi_unpack_external_ = ompi_unpack_external_f
diff --git a/ompi/mpi/fortran/mpif-h/unpack_f.c b/ompi/mpi/fortran/mpif-h/unpack_f.c
index b97e7d09b9a..0b86ec0058b 100644
--- a/ompi/mpi/fortran/mpif-h/unpack_f.c
+++ b/ompi/mpi/fortran/mpif-h/unpack_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_UNPACK = ompi_unpack_f
 #pragma weak pmpi_unpack = ompi_unpack_f
 #pragma weak pmpi_unpack_ = ompi_unpack_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_UNPACK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_UNPACK = ompi_unpack_f
 #pragma weak mpi_unpack = ompi_unpack_f
 #pragma weak mpi_unpack_ = ompi_unpack_f
diff --git a/ompi/mpi/fortran/mpif-h/unpublish_name_f.c b/ompi/mpi/fortran/mpif-h/unpublish_name_f.c
index 80458071f03..7c7d3f72323 100644
--- a/ompi/mpi/fortran/mpif-h/unpublish_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/unpublish_name_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/fortran_base_strings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_UNPUBLISH_NAME = ompi_unpublish_name_f
 #pragma weak pmpi_unpublish_name = ompi_unpublish_name_f
 #pragma weak pmpi_unpublish_name_ = ompi_unpublish_name_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_UNPUBLISH_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_UNPUBLISH_NAME = ompi_unpublish_name_f
 #pragma weak mpi_unpublish_name = ompi_unpublish_name_f
 #pragma weak mpi_unpublish_name_ = ompi_unpublish_name_f
diff --git a/ompi/mpi/fortran/mpif-h/wait_f.c b/ompi/mpi/fortran/mpif-h/wait_f.c
index 7b67686f02e..e5d9e1ddf49 100644
--- a/ompi/mpi/fortran/mpif-h/wait_f.c
+++ b/ompi/mpi/fortran/mpif-h/wait_f.c
@@ -25,7 +25,7 @@
 #include "ompi/mpi/fortran/base/constants.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WAIT = ompi_wait_f
 #pragma weak pmpi_wait = ompi_wait_f
 #pragma weak pmpi_wait_ = ompi_wait_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WAIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WAIT = ompi_wait_f
 #pragma weak mpi_wait = ompi_wait_f
 #pragma weak mpi_wait_ = ompi_wait_f
diff --git a/ompi/mpi/fortran/mpif-h/waitall_f.c b/ompi/mpi/fortran/mpif-h/waitall_f.c
index 29d4664dc74..62da149323e 100644
--- a/ompi/mpi/fortran/mpif-h/waitall_f.c
+++ b/ompi/mpi/fortran/mpif-h/waitall_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WAITALL = ompi_waitall_f
 #pragma weak pmpi_waitall = ompi_waitall_f
 #pragma weak pmpi_waitall_ = ompi_waitall_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WAITALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WAITALL = ompi_waitall_f
 #pragma weak mpi_waitall = ompi_waitall_f
 #pragma weak mpi_waitall_ = ompi_waitall_f
diff --git a/ompi/mpi/fortran/mpif-h/waitany_f.c b/ompi/mpi/fortran/mpif-h/waitany_f.c
index f3bda67c7b4..00ca4fb636d 100644
--- a/ompi/mpi/fortran/mpif-h/waitany_f.c
+++ b/ompi/mpi/fortran/mpif-h/waitany_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WAITANY = ompi_waitany_f
 #pragma weak pmpi_waitany = ompi_waitany_f
 #pragma weak pmpi_waitany_ = ompi_waitany_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WAITANY,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WAITANY = ompi_waitany_f
 #pragma weak mpi_waitany = ompi_waitany_f
 #pragma weak mpi_waitany_ = ompi_waitany_f
diff --git a/ompi/mpi/fortran/mpif-h/waitsome_f.c b/ompi/mpi/fortran/mpif-h/waitsome_f.c
index c3fa1ba35ae..5553ad21e28 100644
--- a/ompi/mpi/fortran/mpif-h/waitsome_f.c
+++ b/ompi/mpi/fortran/mpif-h/waitsome_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WAITSOME = ompi_waitsome_f
 #pragma weak pmpi_waitsome = ompi_waitsome_f
 #pragma weak pmpi_waitsome_ = ompi_waitsome_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WAITSOME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WAITSOME = ompi_waitsome_f
 #pragma weak mpi_waitsome = ompi_waitsome_f
 #pragma weak mpi_waitsome_ = ompi_waitsome_f
diff --git a/ompi/mpi/fortran/mpif-h/win_allocate_f.c b/ompi/mpi/fortran/mpif-h/win_allocate_f.c
index 1685892d1b6..f47412cedba 100644
--- a/ompi/mpi/fortran/mpif-h/win_allocate_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_allocate_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_ALLOCATE = ompi_win_allocate_f
 #pragma weak pmpi_win_allocate = ompi_win_allocate_f
 #pragma weak pmpi_win_allocate_ = ompi_win_allocate_f
@@ -63,7 +63,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_ALLOCATE_CPTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_ALLOCATE = ompi_win_allocate_f
 #pragma weak mpi_win_allocate = ompi_win_allocate_f
 #pragma weak mpi_win_allocate_ = ompi_win_allocate_f
diff --git a/ompi/mpi/fortran/mpif-h/win_allocate_shared_f.c b/ompi/mpi/fortran/mpif-h/win_allocate_shared_f.c
index f5b275c8f5a..9abd3ed3656 100644
--- a/ompi/mpi/fortran/mpif-h/win_allocate_shared_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_allocate_shared_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_ALLOCATE_SHARED = ompi_win_allocate_shared_f
 #pragma weak pmpi_win_allocate_shared = ompi_win_allocate_shared_f
 #pragma weak pmpi_win_allocate_shared_ = ompi_win_allocate_shared_f
@@ -63,7 +63,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_ALLOCATE_SHARED_CPTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_ALLOCATE_SHARED = ompi_win_allocate_shared_f
 #pragma weak mpi_win_allocate_shared = ompi_win_allocate_shared_f
 #pragma weak mpi_win_allocate_shared_ = ompi_win_allocate_shared_f
diff --git a/ompi/mpi/fortran/mpif-h/win_attach_f.c b/ompi/mpi/fortran/mpif-h/win_attach_f.c
index 29bd0447134..b3e6a39385d 100644
--- a/ompi/mpi/fortran/mpif-h/win_attach_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_attach_f.c
@@ -13,7 +13,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_ATTACH = ompi_win_attach_f
 #pragma weak pmpi_win_attach = ompi_win_attach_f
 #pragma weak pmpi_win_attach_ = ompi_win_attach_f
@@ -32,7 +32,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_ATTACH,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_ATTACH = ompi_win_attach_f
 #pragma weak mpi_win_attach = ompi_win_attach_f
 #pragma weak mpi_win_attach_ = ompi_win_attach_f
diff --git a/ompi/mpi/fortran/mpif-h/win_call_errhandler_f.c b/ompi/mpi/fortran/mpif-h/win_call_errhandler_f.c
index 3e3b0cc9c30..8fafe9edd87 100644
--- a/ompi/mpi/fortran/mpif-h/win_call_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_call_errhandler_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_CALL_ERRHANDLER = ompi_win_call_errhandler_f
 #pragma weak pmpi_win_call_errhandler = ompi_win_call_errhandler_f
 #pragma weak pmpi_win_call_errhandler_ = ompi_win_call_errhandler_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_CALL_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_CALL_ERRHANDLER = ompi_win_call_errhandler_f
 #pragma weak mpi_win_call_errhandler = ompi_win_call_errhandler_f
 #pragma weak mpi_win_call_errhandler_ = ompi_win_call_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/win_complete_f.c b/ompi/mpi/fortran/mpif-h/win_complete_f.c
index 4d40ffe4801..ee0a4143fe0 100644
--- a/ompi/mpi/fortran/mpif-h/win_complete_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_complete_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_COMPLETE = ompi_win_complete_f
 #pragma weak pmpi_win_complete = ompi_win_complete_f
 #pragma weak pmpi_win_complete_ = ompi_win_complete_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_COMPLETE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_COMPLETE = ompi_win_complete_f
 #pragma weak mpi_win_complete = ompi_win_complete_f
 #pragma weak mpi_win_complete_ = ompi_win_complete_f
diff --git a/ompi/mpi/fortran/mpif-h/win_create_dynamic_f.c b/ompi/mpi/fortran/mpif-h/win_create_dynamic_f.c
index afc7846228a..e6816c488c3 100644
--- a/ompi/mpi/fortran/mpif-h/win_create_dynamic_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_create_dynamic_f.c
@@ -13,7 +13,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_CREATE_DYNAMIC = ompi_win_create_dynamic_f
 #pragma weak pmpi_win_create_dynamic = ompi_win_create_dynamic_f
 #pragma weak pmpi_win_create_dynamic_ = ompi_win_create_dynamic_f
@@ -32,7 +32,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_CREATE_DYNAMIC,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_CREATE_DYNAMIC = ompi_win_create_dynamic_f
 #pragma weak mpi_win_create_dynamic = ompi_win_create_dynamic_f
 #pragma weak mpi_win_create_dynamic_ = ompi_win_create_dynamic_f
diff --git a/ompi/mpi/fortran/mpif-h/win_create_errhandler_f.c b/ompi/mpi/fortran/mpif-h/win_create_errhandler_f.c
index c46bdcb9bc3..ad97dc7e325 100644
--- a/ompi/mpi/fortran/mpif-h/win_create_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_create_errhandler_f.c
@@ -26,7 +26,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_CREATE_ERRHANDLER = ompi_win_create_errhandler_f
 #pragma weak pmpi_win_create_errhandler = ompi_win_create_errhandler_f
 #pragma weak pmpi_win_create_errhandler_ = ompi_win_create_errhandler_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_CREATE_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_CREATE_ERRHANDLER = ompi_win_create_errhandler_f
 #pragma weak mpi_win_create_errhandler = ompi_win_create_errhandler_f
 #pragma weak mpi_win_create_errhandler_ = ompi_win_create_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/win_create_f.c b/ompi/mpi/fortran/mpif-h/win_create_f.c
index e98ad24a7ae..946e5ceadbf 100644
--- a/ompi/mpi/fortran/mpif-h/win_create_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_create_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_CREATE = ompi_win_create_f
 #pragma weak pmpi_win_create = ompi_win_create_f
 #pragma weak pmpi_win_create_ = ompi_win_create_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_CREATE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_CREATE = ompi_win_create_f
 #pragma weak mpi_win_create = ompi_win_create_f
 #pragma weak mpi_win_create_ = ompi_win_create_f
diff --git a/ompi/mpi/fortran/mpif-h/win_create_keyval_f.c b/ompi/mpi/fortran/mpif-h/win_create_keyval_f.c
index 8ce9842806a..fd94d107fbf 100644
--- a/ompi/mpi/fortran/mpif-h/win_create_keyval_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_create_keyval_f.c
@@ -25,7 +25,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_CREATE_KEYVAL = ompi_win_create_keyval_f
 #pragma weak pmpi_win_create_keyval = ompi_win_create_keyval_f
 #pragma weak pmpi_win_create_keyval_ = ompi_win_create_keyval_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS(PMPI_WIN_CREATE_KEYVAL, pmpi_win_create_keyval, pmpi_
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_CREATE_KEYVAL = ompi_win_create_keyval_f
 #pragma weak mpi_win_create_keyval = ompi_win_create_keyval_f
 #pragma weak mpi_win_create_keyval_ = ompi_win_create_keyval_f
diff --git a/ompi/mpi/fortran/mpif-h/win_delete_attr_f.c b/ompi/mpi/fortran/mpif-h/win_delete_attr_f.c
index c28dd072c18..098d540edd2 100644
--- a/ompi/mpi/fortran/mpif-h/win_delete_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_delete_attr_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_DELETE_ATTR = ompi_win_delete_attr_f
 #pragma weak pmpi_win_delete_attr = ompi_win_delete_attr_f
 #pragma weak pmpi_win_delete_attr_ = ompi_win_delete_attr_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_DELETE_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_DELETE_ATTR = ompi_win_delete_attr_f
 #pragma weak mpi_win_delete_attr = ompi_win_delete_attr_f
 #pragma weak mpi_win_delete_attr_ = ompi_win_delete_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/win_detach_f.c b/ompi/mpi/fortran/mpif-h/win_detach_f.c
index f50aa308ebd..25fd272b0b1 100644
--- a/ompi/mpi/fortran/mpif-h/win_detach_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_detach_f.c
@@ -13,7 +13,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_DETACH = ompi_win_detach_f
 #pragma weak pmpi_win_detach = ompi_win_detach_f
 #pragma weak pmpi_win_detach_ = ompi_win_detach_f
@@ -32,7 +32,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_DETACH,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_DETACH = ompi_win_detach_f
 #pragma weak mpi_win_detach = ompi_win_detach_f
 #pragma weak mpi_win_detach_ = ompi_win_detach_f
diff --git a/ompi/mpi/fortran/mpif-h/win_fence_f.c b/ompi/mpi/fortran/mpif-h/win_fence_f.c
index 0fee45da658..9423561a1ba 100644
--- a/ompi/mpi/fortran/mpif-h/win_fence_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_fence_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_FENCE = ompi_win_fence_f
 #pragma weak pmpi_win_fence = ompi_win_fence_f
 #pragma weak pmpi_win_fence_ = ompi_win_fence_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_FENCE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_FENCE = ompi_win_fence_f
 #pragma weak mpi_win_fence = ompi_win_fence_f
 #pragma weak mpi_win_fence_ = ompi_win_fence_f
diff --git a/ompi/mpi/fortran/mpif-h/win_flush_all_f.c b/ompi/mpi/fortran/mpif-h/win_flush_all_f.c
index fc18ab34eed..78899b176cd 100644
--- a/ompi/mpi/fortran/mpif-h/win_flush_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_flush_all_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_FLUSH_ALL = ompi_win_flush_all_f
 #pragma weak pmpi_win_flush_all = ompi_win_flush_all_f
 #pragma weak pmpi_win_flush_all_ = ompi_win_flush_all_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_FLUSH_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_FLUSH_ALL = ompi_win_flush_all_f
 #pragma weak mpi_win_flush_all = ompi_win_flush_all_f
 #pragma weak mpi_win_flush_all_ = ompi_win_flush_all_f
diff --git a/ompi/mpi/fortran/mpif-h/win_flush_f.c b/ompi/mpi/fortran/mpif-h/win_flush_f.c
index 398703f5011..ffaf4e57ff5 100644
--- a/ompi/mpi/fortran/mpif-h/win_flush_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_flush_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_FLUSH = ompi_win_flush_f
 #pragma weak pmpi_win_flush = ompi_win_flush_f
 #pragma weak pmpi_win_flush_ = ompi_win_flush_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_FLUSH,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_FLUSH = ompi_win_flush_f
 #pragma weak mpi_win_flush = ompi_win_flush_f
 #pragma weak mpi_win_flush_ = ompi_win_flush_f
diff --git a/ompi/mpi/fortran/mpif-h/win_flush_local_all_f.c b/ompi/mpi/fortran/mpif-h/win_flush_local_all_f.c
index 64e869df812..045fb62058a 100644
--- a/ompi/mpi/fortran/mpif-h/win_flush_local_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_flush_local_all_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_FLUSH_LOCAL_ALL = ompi_win_flush_local_all_f
 #pragma weak pmpi_win_flush_local_all = ompi_win_flush_local_all_f
 #pragma weak pmpi_win_flush_local_all_ = ompi_win_flush_local_all_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_FLUSH_LOCAL_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_FLUSH_LOCAL_ALL = ompi_win_flush_local_all_f
 #pragma weak mpi_win_flush_local_all = ompi_win_flush_local_all_f
 #pragma weak mpi_win_flush_local_all_ = ompi_win_flush_local_all_f
diff --git a/ompi/mpi/fortran/mpif-h/win_flush_local_f.c b/ompi/mpi/fortran/mpif-h/win_flush_local_f.c
index 4c2cd92a17c..222dd203547 100644
--- a/ompi/mpi/fortran/mpif-h/win_flush_local_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_flush_local_f.c
@@ -27,7 +27,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_FLUSH_LOCAL = ompi_win_flush_local_f
 #pragma weak pmpi_win_flush_local = ompi_win_flush_local_f
 #pragma weak pmpi_win_flush_local_ = ompi_win_flush_local_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_FLUSH_LOCAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_FLUSH_LOCAL = ompi_win_flush_local_f
 #pragma weak mpi_win_flush_local = ompi_win_flush_local_f
 #pragma weak mpi_win_flush_local_ = ompi_win_flush_local_f
diff --git a/ompi/mpi/fortran/mpif-h/win_free_f.c b/ompi/mpi/fortran/mpif-h/win_free_f.c
index fb59b86f428..1a3c2215b9c 100644
--- a/ompi/mpi/fortran/mpif-h/win_free_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_free_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_FREE = ompi_win_free_f
 #pragma weak pmpi_win_free = ompi_win_free_f
 #pragma weak pmpi_win_free_ = ompi_win_free_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_FREE,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_FREE = ompi_win_free_f
 #pragma weak mpi_win_free = ompi_win_free_f
 #pragma weak mpi_win_free_ = ompi_win_free_f
diff --git a/ompi/mpi/fortran/mpif-h/win_free_keyval_f.c b/ompi/mpi/fortran/mpif-h/win_free_keyval_f.c
index e3d4a2517b4..9b08f70756f 100644
--- a/ompi/mpi/fortran/mpif-h/win_free_keyval_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_free_keyval_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_FREE_KEYVAL = ompi_win_free_keyval_f
 #pragma weak pmpi_win_free_keyval = ompi_win_free_keyval_f
 #pragma weak pmpi_win_free_keyval_ = ompi_win_free_keyval_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_FREE_KEYVAL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_FREE_KEYVAL = ompi_win_free_keyval_f
 #pragma weak mpi_win_free_keyval = ompi_win_free_keyval_f
 #pragma weak mpi_win_free_keyval_ = ompi_win_free_keyval_f
diff --git a/ompi/mpi/fortran/mpif-h/win_get_attr_f.c b/ompi/mpi/fortran/mpif-h/win_get_attr_f.c
index 2f982a48438..adc29c5979b 100644
--- a/ompi/mpi/fortran/mpif-h/win_get_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_get_attr_f.c
@@ -26,7 +26,7 @@
 #include "ompi/win/win.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_GET_ATTR = ompi_win_get_attr_f
 #pragma weak pmpi_win_get_attr = ompi_win_get_attr_f
 #pragma weak pmpi_win_get_attr_ = ompi_win_get_attr_f
@@ -45,7 +45,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_GET_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_GET_ATTR = ompi_win_get_attr_f
 #pragma weak mpi_win_get_attr = ompi_win_get_attr_f
 #pragma weak mpi_win_get_attr_ = ompi_win_get_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/win_get_errhandler_f.c b/ompi/mpi/fortran/mpif-h/win_get_errhandler_f.c
index 28ff7e20936..10f9a609ee9 100644
--- a/ompi/mpi/fortran/mpif-h/win_get_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_get_errhandler_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_GET_ERRHANDLER = ompi_win_get_errhandler_f
 #pragma weak pmpi_win_get_errhandler = ompi_win_get_errhandler_f
 #pragma weak pmpi_win_get_errhandler_ = ompi_win_get_errhandler_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_GET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_GET_ERRHANDLER = ompi_win_get_errhandler_f
 #pragma weak mpi_win_get_errhandler = ompi_win_get_errhandler_f
 #pragma weak mpi_win_get_errhandler_ = ompi_win_get_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/win_get_group_f.c b/ompi/mpi/fortran/mpif-h/win_get_group_f.c
index 5afd0c89870..d47a74713cd 100644
--- a/ompi/mpi/fortran/mpif-h/win_get_group_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_get_group_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_GET_GROUP = ompi_win_get_group_f
 #pragma weak pmpi_win_get_group = ompi_win_get_group_f
 #pragma weak pmpi_win_get_group_ = ompi_win_get_group_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_GET_GROUP,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_GET_GROUP = ompi_win_get_group_f
 #pragma weak mpi_win_get_group = ompi_win_get_group_f
 #pragma weak mpi_win_get_group_ = ompi_win_get_group_f
diff --git a/ompi/mpi/fortran/mpif-h/win_get_info_f.c b/ompi/mpi/fortran/mpif-h/win_get_info_f.c
index dc74ea3f7ec..32419e65d64 100644
--- a/ompi/mpi/fortran/mpif-h/win_get_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_get_info_f.c
@@ -13,7 +13,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_GET_INFO = ompi_win_get_info_f
 #pragma weak pmpi_win_get_info = ompi_win_get_info_f
 #pragma weak pmpi_win_get_info_ = ompi_win_get_info_f
@@ -32,7 +32,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_GET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_GET_INFO = ompi_win_get_info_f
 #pragma weak mpi_win_get_info = ompi_win_get_info_f
 #pragma weak mpi_win_get_info_ = ompi_win_get_info_f
diff --git a/ompi/mpi/fortran/mpif-h/win_get_name_f.c b/ompi/mpi/fortran/mpif-h/win_get_name_f.c
index f5b77ef8ccc..f899d3d076a 100644
--- a/ompi/mpi/fortran/mpif-h/win_get_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_get_name_f.c
@@ -27,7 +27,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_GET_NAME = ompi_win_get_name_f
 #pragma weak pmpi_win_get_name = ompi_win_get_name_f
 #pragma weak pmpi_win_get_name_ = ompi_win_get_name_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_GET_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_GET_NAME = ompi_win_get_name_f
 #pragma weak mpi_win_get_name = ompi_win_get_name_f
 #pragma weak mpi_win_get_name_ = ompi_win_get_name_f
diff --git a/ompi/mpi/fortran/mpif-h/win_lock_all_f.c b/ompi/mpi/fortran/mpif-h/win_lock_all_f.c
index 7c9cc559315..9038dc24fa8 100644
--- a/ompi/mpi/fortran/mpif-h/win_lock_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_lock_all_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_LOCK_ALL = ompi_win_lock_all_f
 #pragma weak pmpi_win_lock_all = ompi_win_lock_all_f
 #pragma weak pmpi_win_lock_all_ = ompi_win_lock_all_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_LOCK_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_LOCK_ALL = ompi_win_lock_all_f
 #pragma weak mpi_win_lock_all = ompi_win_lock_all_f
 #pragma weak mpi_win_lock_all_ = ompi_win_lock_all_f
diff --git a/ompi/mpi/fortran/mpif-h/win_lock_f.c b/ompi/mpi/fortran/mpif-h/win_lock_f.c
index 9d23f1fab20..65d63875994 100644
--- a/ompi/mpi/fortran/mpif-h/win_lock_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_lock_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_LOCK = ompi_win_lock_f
 #pragma weak pmpi_win_lock = ompi_win_lock_f
 #pragma weak pmpi_win_lock_ = ompi_win_lock_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_LOCK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_LOCK = ompi_win_lock_f
 #pragma weak mpi_win_lock = ompi_win_lock_f
 #pragma weak mpi_win_lock_ = ompi_win_lock_f
diff --git a/ompi/mpi/fortran/mpif-h/win_post_f.c b/ompi/mpi/fortran/mpif-h/win_post_f.c
index 05edb0d7ae5..8d6b8757e34 100644
--- a/ompi/mpi/fortran/mpif-h/win_post_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_post_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_POST = ompi_win_post_f
 #pragma weak pmpi_win_post = ompi_win_post_f
 #pragma weak pmpi_win_post_ = ompi_win_post_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_POST,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_POST = ompi_win_post_f
 #pragma weak mpi_win_post = ompi_win_post_f
 #pragma weak mpi_win_post_ = ompi_win_post_f
diff --git a/ompi/mpi/fortran/mpif-h/win_set_attr_f.c b/ompi/mpi/fortran/mpif-h/win_set_attr_f.c
index 056c8c23e6d..1a9f0fe85ac 100644
--- a/ompi/mpi/fortran/mpif-h/win_set_attr_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_set_attr_f.c
@@ -27,7 +27,7 @@
 
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_SET_ATTR = ompi_win_set_attr_f
 #pragma weak pmpi_win_set_attr = ompi_win_set_attr_f
 #pragma weak pmpi_win_set_attr_ = ompi_win_set_attr_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_SET_ATTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_SET_ATTR = ompi_win_set_attr_f
 #pragma weak mpi_win_set_attr = ompi_win_set_attr_f
 #pragma weak mpi_win_set_attr_ = ompi_win_set_attr_f
diff --git a/ompi/mpi/fortran/mpif-h/win_set_errhandler_f.c b/ompi/mpi/fortran/mpif-h/win_set_errhandler_f.c
index d017f8293dc..bfa5c5c42a8 100644
--- a/ompi/mpi/fortran/mpif-h/win_set_errhandler_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_set_errhandler_f.c
@@ -25,7 +25,7 @@
 #include "ompi/errhandler/errhandler.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_SET_ERRHANDLER = ompi_win_set_errhandler_f
 #pragma weak pmpi_win_set_errhandler = ompi_win_set_errhandler_f
 #pragma weak pmpi_win_set_errhandler_ = ompi_win_set_errhandler_f
@@ -44,7 +44,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_SET_ERRHANDLER,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_SET_ERRHANDLER = ompi_win_set_errhandler_f
 #pragma weak mpi_win_set_errhandler = ompi_win_set_errhandler_f
 #pragma weak mpi_win_set_errhandler_ = ompi_win_set_errhandler_f
diff --git a/ompi/mpi/fortran/mpif-h/win_set_info_f.c b/ompi/mpi/fortran/mpif-h/win_set_info_f.c
index 65773fb33eb..69dac004b22 100644
--- a/ompi/mpi/fortran/mpif-h/win_set_info_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_set_info_f.c
@@ -13,7 +13,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_SET_INFO = ompi_win_set_info_f
 #pragma weak pmpi_win_set_info = ompi_win_set_info_f
 #pragma weak pmpi_win_set_info_ = ompi_win_set_info_f
@@ -32,7 +32,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_SET_INFO,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_SET_INFO = ompi_win_set_info_f
 #pragma weak mpi_win_set_info = ompi_win_set_info_f
 #pragma weak mpi_win_set_info_ = ompi_win_set_info_f
diff --git a/ompi/mpi/fortran/mpif-h/win_set_name_f.c b/ompi/mpi/fortran/mpif-h/win_set_name_f.c
index 572f72c2aa7..ed44b2e11d7 100644
--- a/ompi/mpi/fortran/mpif-h/win_set_name_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_set_name_f.c
@@ -27,7 +27,7 @@
 #include "ompi/communicator/communicator.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_SET_NAME = ompi_win_set_name_f
 #pragma weak pmpi_win_set_name = ompi_win_set_name_f
 #pragma weak pmpi_win_set_name_ = ompi_win_set_name_f
@@ -46,7 +46,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_SET_NAME,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_SET_NAME = ompi_win_set_name_f
 #pragma weak mpi_win_set_name = ompi_win_set_name_f
 #pragma weak mpi_win_set_name_ = ompi_win_set_name_f
diff --git a/ompi/mpi/fortran/mpif-h/win_shared_query_f.c b/ompi/mpi/fortran/mpif-h/win_shared_query_f.c
index 5a1fecaf47f..e198970ae1b 100644
--- a/ompi/mpi/fortran/mpif-h/win_shared_query_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_shared_query_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_SHARED_QUERY = ompi_win_shared_query_f
 #pragma weak pmpi_win_shared_query = ompi_win_shared_query_f
 #pragma weak pmpi_win_shared_query_ = ompi_win_shared_query_f
@@ -63,7 +63,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_SHARED_QUERY_CPTR,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_SHARED_QUERY = ompi_win_shared_query_f
 #pragma weak mpi_win_shared_query = ompi_win_shared_query_f
 #pragma weak mpi_win_shared_query_ = ompi_win_shared_query_f
diff --git a/ompi/mpi/fortran/mpif-h/win_start_f.c b/ompi/mpi/fortran/mpif-h/win_start_f.c
index efcf5ecb695..93523ae6441 100644
--- a/ompi/mpi/fortran/mpif-h/win_start_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_start_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_START = ompi_win_start_f
 #pragma weak pmpi_win_start = ompi_win_start_f
 #pragma weak pmpi_win_start_ = ompi_win_start_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_START,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_START = ompi_win_start_f
 #pragma weak mpi_win_start = ompi_win_start_f
 #pragma weak mpi_win_start_ = ompi_win_start_f
diff --git a/ompi/mpi/fortran/mpif-h/win_sync_f.c b/ompi/mpi/fortran/mpif-h/win_sync_f.c
index eed1116d598..d0958c225bf 100644
--- a/ompi/mpi/fortran/mpif-h/win_sync_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_sync_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_SYNC = ompi_win_sync_f
 #pragma weak pmpi_win_sync = ompi_win_sync_f
 #pragma weak pmpi_win_sync_ = ompi_win_sync_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_SYNC,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_SYNC = ompi_win_sync_f
 #pragma weak mpi_win_sync = ompi_win_sync_f
 #pragma weak mpi_win_sync_ = ompi_win_sync_f
diff --git a/ompi/mpi/fortran/mpif-h/win_test_f.c b/ompi/mpi/fortran/mpif-h/win_test_f.c
index 27ed978bc7c..96139611a84 100644
--- a/ompi/mpi/fortran/mpif-h/win_test_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_test_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_TEST = ompi_win_test_f
 #pragma weak pmpi_win_test = ompi_win_test_f
 #pragma weak pmpi_win_test_ = ompi_win_test_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_TEST,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_TEST = ompi_win_test_f
 #pragma weak mpi_win_test = ompi_win_test_f
 #pragma weak mpi_win_test_ = ompi_win_test_f
diff --git a/ompi/mpi/fortran/mpif-h/win_unlock_all_f.c b/ompi/mpi/fortran/mpif-h/win_unlock_all_f.c
index efad4fbad3b..c2ad1e74209 100644
--- a/ompi/mpi/fortran/mpif-h/win_unlock_all_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_unlock_all_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_UNLOCK_ALL = ompi_win_unlock_all_f
 #pragma weak pmpi_win_unlock_all = ompi_win_unlock_all_f
 #pragma weak pmpi_win_unlock_all_ = ompi_win_unlock_all_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_UNLOCK_ALL,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_UNLOCK_ALL = ompi_win_unlock_all_f
 #pragma weak mpi_win_unlock_all = ompi_win_unlock_all_f
 #pragma weak mpi_win_unlock_all_ = ompi_win_unlock_all_f
diff --git a/ompi/mpi/fortran/mpif-h/win_unlock_f.c b/ompi/mpi/fortran/mpif-h/win_unlock_f.c
index 7e2a537b908..7004d2de0cf 100644
--- a/ompi/mpi/fortran/mpif-h/win_unlock_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_unlock_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_UNLOCK = ompi_win_unlock_f
 #pragma weak pmpi_win_unlock = ompi_win_unlock_f
 #pragma weak pmpi_win_unlock_ = ompi_win_unlock_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_UNLOCK,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_UNLOCK = ompi_win_unlock_f
 #pragma weak mpi_win_unlock = ompi_win_unlock_f
 #pragma weak mpi_win_unlock_ = ompi_win_unlock_f
diff --git a/ompi/mpi/fortran/mpif-h/win_wait_f.c b/ompi/mpi/fortran/mpif-h/win_wait_f.c
index 9fe7f5d5201..82b925b828a 100644
--- a/ompi/mpi/fortran/mpif-h/win_wait_f.c
+++ b/ompi/mpi/fortran/mpif-h/win_wait_f.c
@@ -24,7 +24,7 @@
 #include "ompi/mpi/fortran/mpif-h/bindings.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WIN_WAIT = ompi_win_wait_f
 #pragma weak pmpi_win_wait = ompi_win_wait_f
 #pragma weak pmpi_win_wait_ = ompi_win_wait_f
@@ -43,7 +43,7 @@ OMPI_GENERATE_F77_BINDINGS (PMPI_WIN_WAIT,
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WIN_WAIT = ompi_win_wait_f
 #pragma weak mpi_win_wait = ompi_win_wait_f
 #pragma weak mpi_win_wait_ = ompi_win_wait_f
diff --git a/ompi/mpi/fortran/mpif-h/wtick_f.c b/ompi/mpi/fortran/mpif-h/wtick_f.c
index 24da17bfa07..110cd9f6f08 100644
--- a/ompi/mpi/fortran/mpif-h/wtick_f.c
+++ b/ompi/mpi/fortran/mpif-h/wtick_f.c
@@ -32,7 +32,7 @@
  * manually.
  */
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WTICK = ompi_wtick_f
 #pragma weak pmpi_wtick = ompi_wtick_f
 #pragma weak pmpi_wtick_ = ompi_wtick_f
@@ -48,7 +48,7 @@ double pmpi_wtick__(void) { return pompi_wtick_f(); }
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WTICK = ompi_wtick_f
 #pragma weak mpi_wtick = ompi_wtick_f
 #pragma weak mpi_wtick_ = ompi_wtick_f
diff --git a/ompi/mpi/fortran/mpif-h/wtime_f.c b/ompi/mpi/fortran/mpif-h/wtime_f.c
index ce0f18b5ea7..4e2c290b63d 100644
--- a/ompi/mpi/fortran/mpif-h/wtime_f.c
+++ b/ompi/mpi/fortran/mpif-h/wtime_f.c
@@ -32,7 +32,7 @@
  * manually.
  */
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPI_WTIME = ompi_wtime_f
 #pragma weak pmpi_wtime = ompi_wtime_f
 #pragma weak pmpi_wtime_ = ompi_wtime_f
@@ -48,7 +48,7 @@ double pmpi_wtime__(void) { return pompi_wtime_f(); }
 #endif
 #endif
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_WTIME = ompi_wtime_f
 #pragma weak mpi_wtime = ompi_wtime_f
 #pragma weak mpi_wtime_ = ompi_wtime_f
diff --git a/ompi/mpi/fortran/use-mpi-f08/Makefile.am b/ompi/mpi/fortran/use-mpi-f08/Makefile.am
index b098db3485d..953b6bb79ab 100644
--- a/ompi/mpi/fortran/use-mpi-f08/Makefile.am
+++ b/ompi/mpi/fortran/use-mpi-f08/Makefile.am
@@ -15,7 +15,7 @@
 #                         reserved.
 # Copyright (c) 2020      Sandia National Laboratories. All rights reserved.
 # Copyright (c) 2022      IBM Corporation.  All rights reserved.
-# Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2025-2026 Jeffrey M. Squyres.  All rights reserved.
 #
 # $COPYRIGHT$
 #
@@ -445,6 +445,7 @@ api_f08_generated.F90: $(template_files)
 	    --output $(abs_builddir)/$@ \
 	    fortran \
 	    $(gen_ts) \
+	    --pympistd-dir $(abs_top_srcdir)/3rd-party/pympistandard \
 	    code \
 	    --lang fortran \
 	    --prototype-files $(template_files)
@@ -459,6 +460,23 @@ endif
 
 ###########################################################################
 
+# Validate that the mpi_f08 interfaces -- both the generated
+# (api_f08_generated.F90) and the hand-written (*_f08.F90) ones -- use the
+# parameter names, types, and intents mandated by the MPI standard, as
+# provided by the pympistandard submodule.  Run during "make check"; fails
+# if any mpi_f08 interface drifts from the standard.  The hand-written
+# sources live in $(srcdir); api_f08_generated.F90 is in the build directory
+# (built by "all", on which "check" depends).
+f08_name_check_handwritten = $(filter-out api_f08_generated.F90,$(mpi_api_files))
+
+check-local:
+	@$(PYTHON) $(top_srcdir)/ompi/mpi/bindings/check_f08_names.py \
+	    --label "mpi_f08 bindings (generated + hand-written)" \
+	    --pympistd-dir $(abs_top_srcdir)/3rd-party/pympistandard \
+	    api_f08_generated.F90 $(f08_name_check_handwritten:%=$(srcdir)/%)
+
+###########################################################################
+
 # Install the generated .mod files.  Unfortunately, each F90 compiler
 # may generate different filenames, so we have to use a glob.  :-(
 
diff --git a/ompi/mpi/fortran/use-mpi-f08/Makefile.prototype_files b/ompi/mpi/fortran/use-mpi-f08/Makefile.prototype_files
index 1bcd67acbbc..dfe4d70c7d4 100644
--- a/ompi/mpi/fortran/use-mpi-f08/Makefile.prototype_files
+++ b/ompi/mpi/fortran/use-mpi-f08/Makefile.prototype_files
@@ -160,7 +160,13 @@ prototype_files = \
         session_iflush_buffer.c.in \
         ssend_init_ts.c.in \
         ssend_ts.c.in \
+        status_get_error.c.in \
+        status_get_source.c.in \
+        status_get_tag.c.in \
         status_set_elements.c.in \
+        status_set_error.c.in \
+        status_set_source.c.in \
+        status_set_tag.c.in \
         testany.c.in \
         type_contiguous.c.in \
         type_create_darray.c.in \
diff --git a/ompi/mpi/fortran/use-mpi-f08/allgatherv_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/allgatherv_init_ts.c.in
index c559a5f107a..9c540a98e4d 100644
--- a/ompi/mpi/fortran/use-mpi-f08/allgatherv_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/allgatherv_init_ts.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -97,4 +97,7 @@ PROTOTYPE VOID allgatherv_init(BUFFER_ASYNC x1, COUNT sendcount, DATATYPE sendty
     }
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/alltoallv_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/alltoallv_init_ts.c.in
index 0b1608fd32f..853a4039d94 100644
--- a/ompi/mpi/fortran/use-mpi-f08/alltoallv_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/alltoallv_init_ts.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -85,4 +85,7 @@ PROTOTYPE VOID alltoallv_init(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts, DISP_ARRA
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sdispls, tmp_sdispls, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(rdispls, tmp_rdispls, c_request, c_ierr, idx);
+    if (idx > 0) {
+       ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/alltoallw_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/alltoallw_init_ts.c.in
index 34765cd1af1..ae239107b7d 100644
--- a/ompi/mpi/fortran/use-mpi-f08/alltoallw_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/alltoallw_init_ts.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -88,10 +88,12 @@ PROTOTYPE VOID alltoallw_init(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts,
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
         if (NULL != c_sendtypes) {
-            free(c_sendtypes);
+            ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
         }
-        free(c_recvtypes);
+        ompi_coll_base_append_array_to_release(c_request, c_recvtypes);
+        ompi_coll_base_add_release_arrays_cb(c_request);
     }
+
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sdispls, tmp_sdispls, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
diff --git a/ompi/mpi/fortran/use-mpi-f08/base/bigcount.h b/ompi/mpi/fortran/use-mpi-f08/base/bigcount.h
index d7dd109005b..535737f2011 100644
--- a/ompi/mpi/fortran/use-mpi-f08/base/bigcount.h
+++ b/ompi/mpi/fortran/use-mpi-f08/base/bigcount.h
@@ -45,11 +45,10 @@
 #define OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(array, tmp_array, c_request, c_ierr, idx) \
     do { \
         if (MPI_SUCCESS == (c_ierr)) { \
-            ompi_coll_base_nbc_request_t* nb_request = (ompi_coll_base_nbc_request_t*)c_request; \
             if ((void *)(array) != (void *)(tmp_array) && (tmp_array) != NULL) { \
-                nb_request->data.release_arrays[(idx)++] = tmp_array; \
+                ompi_coll_base_append_array_to_release((c_request), (tmp_array)); \
+                (idx)++;                                                         \
             } \
-            nb_request->data.release_arrays[idx] = NULL; \
         } else { \
             OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP((array), (tmp_array)); \
         } \
diff --git a/ompi/mpi/fortran/use-mpi-f08/buffer_attach_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/buffer_attach_ts.c.in
index 93e3b956d3b..e131768a195 100644
--- a/ompi/mpi/fortran/use-mpi-f08/buffer_attach_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/buffer_attach_ts.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -27,7 +28,7 @@ PROTOTYPE VOID buffer_attach(BUFFER_ASYNC x, COUNT size)
     @COUNT_TYPE@ c_size = (@COUNT_TYPE@)*size;
 
     if (OMPI_CFI_IS_CONTIGUOUS(x)) {
-        c_ierr = PMPI_Buffer_attach(OMPI_CFI_BASE_ADDR(x), c_size);
+        c_ierr = PMPI_Buffer_attach(OMPI_F2C_BUFFER_AUTOMATIC(OMPI_CFI_BASE_ADDR(x)), c_size);
     } else {
         c_ierr = MPI_ERR_BUFFER;
         OMPI_ERRHANDLER_INVOKE(MPI_COMM_SELF, c_ierr, FUNC_NAME);
diff --git a/ompi/mpi/fortran/use-mpi-f08/buffer_detach.c.in b/ompi/mpi/fortran/use-mpi-f08/buffer_detach.c.in
index 1769ca93a5f..db907a75228 100644
--- a/ompi/mpi/fortran/use-mpi-f08/buffer_detach.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/buffer_detach.c.in
@@ -15,6 +15,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -22,17 +23,17 @@
  * $HEADER$
  */
 
-PROTOTYPE VOID buffer_detach(C_PTR_OUT buffer, COUNT size)
+PROTOTYPE VOID buffer_detach(C_PTR_OUT buffer, COUNT_OUT size)
 {
     int c_ierr;
     @COUNT_TYPE@ c_size;
 
-    c_ierr = @INNER_CALL@(&buffer, &c_size);
+    c_ierr = @INNER_CALL@(buffer, &c_size);
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
 
     if (MPI_SUCCESS == c_ierr) {
         *size = (@COUNT_FINT_TYPE@)(c_size);
-        if (MPI_BUFFER_AUTOMATIC == buffer) {
+        if (MPI_BUFFER_AUTOMATIC == *((void **)buffer)) {
             *((void **)buffer) = OMPI_FORTRAN_BUFFER_AUTOMATIC_ADDR();
         }
     }
diff --git a/ompi/mpi/fortran/use-mpi-f08/comm_attach_buffer_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/comm_attach_buffer_ts.c.in
index 75ec71d86b9..aadb7318cd7 100644
--- a/ompi/mpi/fortran/use-mpi-f08/comm_attach_buffer_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/comm_attach_buffer_ts.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,7 +29,7 @@ PROTOTYPE VOID comm_attach_buffer(COMM comm, BUFFER_ASYNC x, COUNT size)
     @COUNT_TYPE@ c_size = (@COUNT_TYPE@)*size;
 
     if (OMPI_CFI_IS_CONTIGUOUS(x)) {
-        c_ierr = PMPI_Comm_attach_buffer(c_comm, OMPI_CFI_BASE_ADDR(x), c_size);
+        c_ierr = PMPI_Comm_attach_buffer(c_comm, OMPI_F2C_BUFFER_AUTOMATIC(OMPI_CFI_BASE_ADDR(x)), c_size);
     } else {
         c_ierr = MPI_ERR_BUFFER;
         OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
diff --git a/ompi/mpi/fortran/use-mpi-f08/comm_detach_buffer.c.in b/ompi/mpi/fortran/use-mpi-f08/comm_detach_buffer.c.in
index e18728e4759..ecd2cc576f6 100644
--- a/ompi/mpi/fortran/use-mpi-f08/comm_detach_buffer.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/comm_detach_buffer.c.in
@@ -15,6 +15,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -22,7 +23,7 @@
  * $HEADER$
  */
 
-PROTOTYPE VOID comm_detach_buffer(COMM comm, C_PTR_OUT buffer, COUNT size)
+PROTOTYPE VOID comm_detach_buffer(COMM comm, C_PTR_OUT buffer, COUNT_OUT size)
 {
     int c_ierr;
     MPI_Comm c_comm;
@@ -35,7 +36,7 @@ PROTOTYPE VOID comm_detach_buffer(COMM comm, C_PTR_OUT buffer, COUNT size)
 
     if (MPI_SUCCESS == c_ierr) {
         *size = (@COUNT_FINT_TYPE@)(c_size);
-        if (MPI_BUFFER_AUTOMATIC == buffer) {
+        if (MPI_BUFFER_AUTOMATIC == *((void **)buffer)) {
             *((void **)buffer) = OMPI_FORTRAN_BUFFER_AUTOMATIC_ADDR();
         }
     }
diff --git a/ompi/mpi/fortran/use-mpi-f08/gatherv_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/gatherv_init_ts.c.in
index da4c954cebb..5c35dd094e6 100644
--- a/ompi/mpi/fortran/use-mpi-f08/gatherv_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/gatherv_init_ts.c.in
@@ -111,5 +111,8 @@ PROTOTYPE VOID gatherv_init(BUFFER_ASYNC x1, COUNT sendcount, DATATYPE sendtype,
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
 
diff --git a/ompi/mpi/fortran/use-mpi-f08/get_address_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/get_address_ts.c.in
index d672e8c1139..5a02209826c 100644
--- a/ompi/mpi/fortran/use-mpi-f08/get_address_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/get_address_ts.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2024      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -21,7 +22,7 @@
  * $HEADER$
  */
 
-PROTOTYPE VOID get_address(BUFFER_ASYNC x, AINT address)
+PROTOTYPE VOID get_address(BUFFER_ASYNC x, AINT_OUT address)
 {
     int c_ierr;
     MPI_Aint c_address;
diff --git a/ompi/mpi/fortran/use-mpi-f08/iallgatherv_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/iallgatherv_ts.c.in
index 0323d69bb33..4a279711df2 100644
--- a/ompi/mpi/fortran/use-mpi-f08/iallgatherv_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/iallgatherv_ts.c.in
@@ -25,7 +25,7 @@ PROTOTYPE VOID iallgatherv(BUFFER_ASYNC x1, COUNT sendcount, DATATYPE sendtype,
                            BUFFER_ASYNC_OUT x2, COUNT_ARRAY recvcounts, DISP_ARRAY displs,
                            DATATYPE recvtype, COMM comm, REQUEST_OUT request)
 {
-    int c_ierr;
+    int c_ierr, idx = 0;
     MPI_Comm c_comm = PMPI_Comm_f2c(*comm);
     @COUNT_TYPE@ c_sendcount = (@COUNT_TYPE@)*sendcount;
     MPI_Datatype c_sendtype = NULL, c_senddatatype = NULL;
@@ -86,6 +86,10 @@ PROTOTYPE VOID iallgatherv(BUFFER_ASYNC x1, COUNT sendcount, DATATYPE sendtype,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) *request = PMPI_Request_c2f(c_request);
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(recvcounts, tmp_recvcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(displs, tmp_displs);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
+
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/ialltoallv_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/ialltoallv_ts.c.in
index 1e6b401f934..fc12804dbb7 100644
--- a/ompi/mpi/fortran/use-mpi-f08/ialltoallv_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/ialltoallv_ts.c.in
@@ -26,7 +26,7 @@ PROTOTYPE VOID ialltoallv(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts, DISP_ARRAY sd
                           DISP_ARRAY rdispls, DATATYPE recvtype,
                           COMM comm, REQUEST_OUT request)
 {
-    int c_ierr;
+    int c_ierr, idx = 0;
     MPI_Comm c_comm = PMPI_Comm_f2c(*comm);
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     MPI_Datatype c_sendtype = NULL, c_recvtype = PMPI_Type_f2c(*recvtype);
@@ -76,8 +76,12 @@ PROTOTYPE VOID ialltoallv(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts, DISP_ARRAY sd
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) *request = PMPI_Request_c2f(c_request);
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(sendcounts, tmp_sendcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(sdispls, tmp_sdispls);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(recvcounts, tmp_recvcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(rdispls, tmp_rdispls);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sdispls, tmp_sdispls, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(rdispls, tmp_rdispls, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
+
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/ialltoallw_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/ialltoallw_ts.c.in
index dbeebf41910..23b2c19a343 100644
--- a/ompi/mpi/fortran/use-mpi-f08/ialltoallw_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/ialltoallw_ts.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -30,7 +30,7 @@ PROTOTYPE VOID ialltoallw(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts,
     MPI_Comm c_comm = PMPI_Comm_f2c(*comm);
     MPI_Datatype *c_sendtypes = NULL, *c_recvtypes;
     MPI_Request c_request;
-    int size, c_ierr;
+    int size, idx = 0, c_ierr;
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     @COUNT_TYPE@ *tmp_sendcounts = NULL;
     @DISP_TYPE@ *tmp_sdispls = NULL;
@@ -82,12 +82,13 @@ PROTOTYPE VOID ialltoallw(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) *request = PMPI_Request_c2f(c_request);
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(sendcounts, tmp_sendcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(sdispls, tmp_sdispls);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(recvcounts, tmp_recvcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(rdispls, tmp_rdispls);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sdispls, tmp_sdispls, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);;
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(rdispls, tmp_rdispls, c_request, c_ierr, idx);
+    ompi_coll_base_append_array_to_release(c_request, c_recvtypes);
     if (NULL != c_sendtypes) {
-        free(c_sendtypes);
+        ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
     }
-    free(c_recvtypes);
+    ompi_coll_base_add_release_arrays_cb(c_request);
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/igatherv_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/igatherv_ts.c.in
index f5f51bbd023..ea156532277 100644
--- a/ompi/mpi/fortran/use-mpi-f08/igatherv_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/igatherv_ts.c.in
@@ -101,5 +101,8 @@ PROTOTYPE VOID igatherv(BUFFER_ASYNC x1, COUNT sendcount, DATATYPE sendtype,
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/ineighbor_allgatherv_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/ineighbor_allgatherv_ts.c.in
index 6cffe2c3007..13c1e80361a 100644
--- a/ompi/mpi/fortran/use-mpi-f08/ineighbor_allgatherv_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/ineighbor_allgatherv_ts.c.in
@@ -15,7 +15,7 @@
  *                         reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -35,7 +35,7 @@ PROTOTYPE VOID ineighbor_allgatherv(BUFFER_ASYNC x1, COUNT sendcount, DATATYPE s
     @COUNT_TYPE@ c_sendcount = (@COUNT_TYPE@) *sendcount;
     MPI_Datatype c_recvtype = PMPI_Type_f2c(*recvtype);
     MPI_Request c_request;
-    int size, c_ierr;
+    int size, c_ierr, idx = 0;
     @COUNT_TYPE@ *tmp_recvcounts = NULL;
     @DISP_TYPE@ *tmp_displs = NULL;
 
@@ -73,6 +73,9 @@ PROTOTYPE VOID ineighbor_allgatherv(BUFFER_ASYNC x1, COUNT sendcount, DATATYPE s
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) *request = PMPI_Request_c2f(c_request);
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(recvcounts, tmp_recvcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(displs, tmp_displs);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallv_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallv_ts.c.in
index 1de86c01d45..2eac4c05b8c 100644
--- a/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallv_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallv_ts.c.in
@@ -15,7 +15,7 @@
  *                         reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -32,7 +32,7 @@ PROTOTYPE VOID ineighbor_alltoallv(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts, DISP
     MPI_Comm c_comm = PMPI_Comm_f2c(*comm);
     MPI_Datatype c_sendtype, c_recvtype;
     MPI_Request c_request;
-    int size, c_ierr;
+    int indegree, outdegree, idx = 0, c_ierr;
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     @COUNT_TYPE@ *tmp_sendcounts = NULL;
     @DISP_TYPE@ *tmp_sdispls = NULL;
@@ -55,11 +55,17 @@ PROTOTYPE VOID ineighbor_alltoallv(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts, DISP
     c_sendtype = PMPI_Type_f2c(*sendtype);
     c_recvtype = PMPI_Type_f2c(*recvtype);
 
-    PMPI_Comm_size(c_comm, &size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
+        return;
+    }
+
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, indegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, indegree);
 
     sendbuf = (char *) OMPI_F2C_IN_PLACE(sendbuf);
     sendbuf = (char *) OMPI_F2C_BOTTOM(sendbuf);
@@ -76,8 +82,11 @@ PROTOTYPE VOID ineighbor_alltoallv(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts, DISP
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) *request = PMPI_Request_c2f(c_request);
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(sendcounts, tmp_sendcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(sdispls, tmp_sdispls);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(recvcounts, tmp_recvcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(rdispls, tmp_rdispls);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts,c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sdispls, tmp_sdispls, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(rdispls, tmp_rdispls, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallw_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallw_ts.c.in
index 4c387b3dcde..fb8babef69a 100644
--- a/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallw_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/ineighbor_alltoallw_ts.c.in
@@ -15,7 +15,7 @@
  *                         reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -33,7 +33,7 @@ PROTOTYPE VOID ineighbor_alltoallw(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts,
     MPI_Comm c_comm = PMPI_Comm_f2c(*comm);
     MPI_Datatype *c_sendtypes, *c_recvtypes;
     MPI_Request c_request;
-    int size, c_ierr;
+    int indegree, outdegree, idx = 0, c_ierr;
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     @COUNT_TYPE@ *tmp_sendcounts = NULL;
     @COUNT_TYPE@ *tmp_recvcounts = NULL;
@@ -50,18 +50,28 @@ PROTOTYPE VOID ineighbor_alltoallw(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts,
         OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
         return;
     }
-    PMPI_Comm_size(c_comm, &size);
 
-    c_sendtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
-    c_recvtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
+        return;
+    }
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, size);
+    c_sendtypes = (MPI_Datatype *) malloc(outdegree * sizeof(MPI_Datatype));
+    c_recvtypes = (MPI_Datatype *) malloc(indegree * sizeof(MPI_Datatype));
 
-    while (size > 0) {
-        c_sendtypes[size - 1] = PMPI_Type_f2c(sendtypes[size - 1]);
-        c_recvtypes[size - 1] = PMPI_Type_f2c(recvtypes[size - 1]);
-        --size;
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, indegree);
+
+    while (outdegree > 0) {
+        c_sendtypes[outdegree - 1] = PMPI_Type_f2c(sendtypes[outdegree - 1]);
+        --outdegree;
+    }
+
+    while (indegree > 0) {
+        c_recvtypes[indegree - 1] = PMPI_Type_f2c(recvtypes[indegree - 1]);
+        --indegree;
     }
 
     /* Ineighbor_alltoallw does not support MPI_IN_PLACE */
@@ -77,10 +87,15 @@ PROTOTYPE VOID ineighbor_alltoallw(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts,
                           rdispls,
                           c_recvtypes, c_comm, &c_request);
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
-    if (MPI_SUCCESS == c_ierr) *request = PMPI_Request_c2f(c_request);
-
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(sendcounts, tmp_sendcounts);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP(recvcounts, tmp_recvcounts);
-    free(c_sendtypes);
-    free(c_recvtypes);
+    if (MPI_SUCCESS == c_ierr) {
+        *request = PMPI_Request_c2f(c_request);
+        OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
+        OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
+        ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
+        ompi_coll_base_append_array_to_release(c_request, c_recvtypes);
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    } else {
+        free(c_sendtypes);
+        free(c_recvtypes);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/ireduce_scatter_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/ireduce_scatter_ts.c.in
index e6c319b03e3..ad5a874dab4 100644
--- a/ompi/mpi/fortran/use-mpi-f08/ireduce_scatter_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/ireduce_scatter_ts.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -62,5 +62,8 @@ PROTOTYPE VOID ireduce_scatter(BUFFER_ASYNC x1, BUFFER_ASYNC_OUT x2,
     if (MPI_SUCCESS == c_ierr) *request = PMPI_Request_c2f(c_request);
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/iscatterv_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/iscatterv_ts.c.in
index 7f983faed51..b783198dca3 100644
--- a/ompi/mpi/fortran/use-mpi-f08/iscatterv_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/iscatterv_ts.c.in
@@ -13,7 +13,7 @@
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -106,4 +106,7 @@ PROTOTYPE VOID iscatterv(BUFFER_ASYNC x1, COUNT_ARRAY sendcounts,
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+       ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/mod/Makefile.am b/ompi/mpi/fortran/use-mpi-f08/mod/Makefile.am
index 39a80c2f76f..ce732dc735c 100644
--- a/ompi/mpi/fortran/use-mpi-f08/mod/Makefile.am
+++ b/ompi/mpi/fortran/use-mpi-f08/mod/Makefile.am
@@ -13,6 +13,7 @@
 # Copyright (C) 2024-2026 Triad National Security, LLC. All rights
 #                         reserved.
 #
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -93,6 +94,7 @@ mpi-f08-interfaces-generated.h: $(template_files)
 	    --output $(abs_builddir)/$@ \
 	    fortran \
 	    $(gen_ts) \
+	    --pympistd-dir $(abs_top_srcdir)/3rd-party/pympistandard \
 	    --fort-std f08 \
 	    interface \
 	    --prototype-files $(template_files)
@@ -103,6 +105,18 @@ if OPAL_DEVEL_BUILD
 CLEANFILES += mpi-f08-interfaces-generated.h
 endif
 
+# Validate that the mpi_f08 interface specifications -- the user-visible
+# explicit interfaces, generated separately from the implementations -- use
+# the parameter names, types, and intents mandated by the MPI standard (via
+# the pympistandard submodule).  Run during "make check"; fails on any
+# drift.  Both headers are generated in the build directory (built by
+# "all", on which "check" depends).
+check-local:
+	@$(PYTHON) $(top_srcdir)/ompi/mpi/bindings/check_f08_names.py \
+	    --label "mpi_f08 interface specifications" \
+	    --pympistd-dir $(abs_top_srcdir)/3rd-party/pympistandard \
+	    mpi-f08-interfaces-generated.h mpi-f08-interfaces.h
+
 #
 # Automake doesn't do Fortran dependency analysis, so must list them
 # manually here.  Bummer!
diff --git a/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in
index e2ec132302d..39a2c1c7800 100644
--- a/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in
+++ b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in
@@ -13,6 +13,7 @@
 ! Copyright (c) 2021-2023 Triad National Security, LLC. All rights
 !                         reserved.
 ! Copyright (c) 2025      UT-Battelle, LLC.  All rights reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 ! $COPYRIGHT$
 !
 ! This file provides the interface specifications for the MPI Fortran
@@ -52,11 +53,11 @@ end subroutine MPI_Pready_f08
 end interface  MPI_Pready
 
 interface  MPI_Pready_list
-subroutine MPI_Pready_list_f08(length,partitions,request,ierror)
+subroutine MPI_Pready_list_f08(length,array_of_partitions,request,ierror)
    use :: mpi_f08_types, only : MPI_Request
    implicit none
    INTEGER, INTENT(IN) :: length
-   INTEGER, DIMENSION(*), INTENT(IN) :: partitions
+   INTEGER, DIMENSION(*), INTENT(IN) :: array_of_partitions
    TYPE(MPI_Request), INTENT(IN) :: request
    INTEGER, OPTIONAL, INTENT(OUT) :: ierror
 end subroutine MPI_Pready_list_f08
@@ -135,11 +136,11 @@ end subroutine MPI_Session_get_errhandler_f08
 end interface MPI_Session_get_errhandler
 
 interface MPI_Session_get_info
-subroutine MPI_Session_get_info_f08(session, info, ierror)
+subroutine MPI_Session_get_info_f08(session, info_used, ierror)
    use :: mpi_f08_types, only : MPI_Session, MPI_Info
    implicit none
    TYPE(MPI_Session), INTENT(IN) :: session
-   TYPE(MPI_Info), INTENT(OUT) :: info
+   TYPE(MPI_Info), INTENT(OUT) :: info_used
    INTEGER, OPTIONAL, INTENT(OUT) :: ierror
 end subroutine MPI_Session_get_info_f08
 end interface MPI_Session_get_info
diff --git a/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h
index 4010a6bbd8e..f8cd8cf092b 100644
--- a/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h
+++ b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h
@@ -610,10 +610,7 @@
 #define MPI_Session_get_errhandler PMPI_Session_get_errhandler
 #define MPI_Session_get_info_f08 PMPI_Session_get_info_f08
 #define MPI_Session_get_info PMPI_Session_get_info
-#define MPI_Session_get_info PMPI_Session_get_info
 #define MPI_Session_get_nth_pset_f08 PMPI_Session_get_nth_pset_f08
-#define MPI_Session_get_nth_psetlen_f08 PMPI_Session_get_nth_psetlen_f08
-#define MPI_Session_get_nth_psetlen PMPI_Session_get_nth_psetlen
 #define MPI_Session_get_nth_pset PMPI_Session_get_nth_pset
 #define MPI_Session_get_num_psets_f08 PMPI_Session_get_num_psets_f08
 #define MPI_Session_get_num_psets PMPI_Session_get_num_psets
diff --git a/ompi/mpi/fortran/use-mpi-f08/neighbor_allgatherv_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/neighbor_allgatherv_init_ts.c.in
index 394debf1c27..2d59884292e 100644
--- a/ompi/mpi/fortran/use-mpi-f08/neighbor_allgatherv_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/neighbor_allgatherv_init_ts.c.in
@@ -84,4 +84,7 @@ PROTOTYPE VOID neighbor_allgatherv_init(BUFFER x1, COUNT sendcount, DATATYPE sen
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_init_ts.c.in
index 0a5729ccb03..24442c09e4a 100644
--- a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_init_ts.c.in
@@ -15,7 +15,7 @@
  *                         reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -36,7 +36,7 @@ PROTOTYPE VOID neighbor_alltoallv_init(BUFFER x1, COUNT_ARRAY sendcounts, DISP_A
     MPI_Datatype c_recvtype = PMPI_Type_f2c(*recvtype);;
     MPI_Info c_info;
     MPI_Request c_request;
-    int size, c_ierr, idx = 0;
+    int indegree, outdegree, c_ierr, idx = 0;
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     @COUNT_TYPE@ *tmp_sendcounts = NULL;
     @DISP_TYPE@ *tmp_sdispls = NULL;
@@ -58,11 +58,17 @@ PROTOTYPE VOID neighbor_alltoallv_init(BUFFER x1, COUNT_ARRAY sendcounts, DISP_A
         return;
     }
 
-    PMPI_Comm_size(c_comm, &size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
+        return;
+    }
+
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, indegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, indegree);
 
     sendbuf = (char *) OMPI_F2C_IN_PLACE(sendbuf);
     sendbuf = (char *) OMPI_F2C_BOTTOM(sendbuf);
@@ -89,4 +95,7 @@ PROTOTYPE VOID neighbor_alltoallv_init(BUFFER x1, COUNT_ARRAY sendcounts, DISP_A
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(rdispls, tmp_rdispls, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sdispls, tmp_sdispls, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_ts.c.in
index 8610e0221d3..9873104d22e 100644
--- a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallv_ts.c.in
@@ -15,7 +15,7 @@
  *                         reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -32,7 +32,7 @@ PROTOTYPE VOID neighbor_alltoallv(BUFFER x1, COUNT_ARRAY sendcounts, DISP_ARRAY
     MPI_Comm c_comm = PMPI_Comm_f2c(*comm);
     MPI_Datatype c_sendtype = PMPI_Type_f2c(*sendtype);
     MPI_Datatype c_recvtype = PMPI_Type_f2c(*recvtype);
-    int size, c_ierr;
+    int indegree, outdegree, c_ierr;
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     @COUNT_TYPE@ *tmp_sendcounts = NULL;
     @DISP_TYPE@ *tmp_sdispls = NULL;
@@ -52,11 +52,17 @@ PROTOTYPE VOID neighbor_alltoallv(BUFFER x1, COUNT_ARRAY sendcounts, DISP_ARRAY
         return;
     }
 
-    PMPI_Comm_size(c_comm, &size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, size);
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
+        return;
+    }
+
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, indegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, indegree);
 
     sendbuf = (char *) OMPI_F2C_IN_PLACE(sendbuf);
     sendbuf = (char *) OMPI_F2C_BOTTOM(sendbuf);
diff --git a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_init_ts.c.in
index 8a514759b41..c6da64686b6 100644
--- a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_init_ts.c.in
@@ -15,7 +15,7 @@
  *                         reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -36,11 +36,11 @@ PROTOTYPE VOID neighbor_alltoallw_init(BUFFER x1, COUNT_ARRAY sendcounts,
     MPI_Datatype *c_sendtypes, *c_recvtypes;
     MPI_Request c_request;
     MPI_Info c_info;
-    int size, c_ierr, idx = 0;
+    int indegree, outdegree,  c_ierr, idx = 0;
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     @COUNT_TYPE@ *tmp_sendcounts = NULL;
     @COUNT_TYPE@ *tmp_recvcounts = NULL;
-    MPI_Aint *tmp_sdispls = NULL, *tmp_rdispls;
+    MPI_Aint *tmp_sdispls = NULL, *tmp_rdispls = NULL;
 
     c_info = PMPI_Info_f2c(*info);
 
@@ -56,24 +56,34 @@ PROTOTYPE VOID neighbor_alltoallw_init(BUFFER x1, COUNT_ARRAY sendcounts,
         OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME)
         return;
     }
-    PMPI_Comm_size(c_comm, &size);
 
-    c_sendtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
-    c_recvtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
+        return;
+    }
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, size);
+    c_sendtypes = (MPI_Datatype *) malloc(outdegree * sizeof(MPI_Datatype));
+    c_recvtypes = (MPI_Datatype *) malloc(indegree * sizeof(MPI_Datatype));
+
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, indegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sdispls, tmp_sdispls, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(rdispls, tmp_rdispls, indegree);
 
     /* Alltoallw does not support MPI_IN_PLACE */
     sendbuf = (char *) OMPI_F2C_BOTTOM(sendbuf);
     recvbuf = (char *) OMPI_F2C_BOTTOM(recvbuf);
 
-    while (size > 0) {
-        c_sendtypes[size - 1] = PMPI_Type_f2c(sendtypes[size - 1]);
-        c_recvtypes[size - 1] = PMPI_Type_f2c(recvtypes[size - 1]);
-        --size;
+    while (outdegree > 0) {
+        c_sendtypes[outdegree - 1] = PMPI_Type_f2c(sendtypes[outdegree - 1]);
+        --outdegree;
+    }
+
+    while (indegree > 0) {
+        c_recvtypes[indegree - 1] = PMPI_Type_f2c(recvtypes[indegree - 1]);
+        --indegree;
     }
 
     c_ierr = @INNER_CALL@(sendbuf,
@@ -90,13 +100,16 @@ PROTOTYPE VOID neighbor_alltoallw_init(BUFFER x1, COUNT_ARRAY sendcounts,
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
     if (MPI_SUCCESS == c_ierr) {
         *request = PMPI_Request_c2f(c_request);
+        ompi_coll_base_append_array_to_release(c_request, c_sendtypes);
+        ompi_coll_base_append_array_to_release(c_request, c_recvtypes);
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    } else {
+        free(c_sendtypes);
+        free(c_recvtypes);
     }
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(rdispls, tmp_rdispls, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sdispls, tmp_sdispls, c_request, c_ierr, idx);
-
-    free(c_sendtypes);
-    free(c_recvtypes);
 }
diff --git a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_ts.c.in
index e4dc0181dc7..c6a141360fb 100644
--- a/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/neighbor_alltoallw_ts.c.in
@@ -15,7 +15,7 @@
  *                         reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -32,7 +32,7 @@ PROTOTYPE VOID neighbor_alltoallw(BUFFER x1, COUNT_ARRAY sendcounts,
 {
     MPI_Comm c_comm = PMPI_Comm_f2c(*comm);
     MPI_Datatype *c_sendtypes, *c_recvtypes;
-    int size, c_ierr;
+    int indegree, outdegree, c_ierr;
     char *sendbuf = OMPI_CFI_BASE_ADDR(x1), *recvbuf = OMPI_CFI_BASE_ADDR(x2);
     @COUNT_TYPE@ *tmp_sendcounts = NULL;
     @COUNT_TYPE@ *tmp_recvcounts = NULL;
@@ -49,18 +49,27 @@ PROTOTYPE VOID neighbor_alltoallw(BUFFER x1, COUNT_ARRAY sendcounts,
         OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME)
         return;
     }
-    PMPI_Comm_size(c_comm, &size);
 
-    c_sendtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
-    c_recvtypes = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
+    c_ierr = ompi_fortran_neighbor_count(c_comm, &indegree, &outdegree);
+    if (MPI_SUCCESS != c_ierr) {
+        if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+        OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME);
+        return;
+    }
+
+    c_sendtypes = (MPI_Datatype *) malloc(outdegree * sizeof(MPI_Datatype));
+    c_recvtypes = (MPI_Datatype *) malloc(indegree * sizeof(MPI_Datatype));
 
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, size);
-    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, size);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(sendcounts, tmp_sendcounts, outdegree);
+    OMPI_FORTRAN_BIGCOUNT_ARRAY_SET(recvcounts, tmp_recvcounts, indegree);
 
-    while (size > 0) {
-        c_sendtypes[size - 1] = PMPI_Type_f2c(sendtypes[size - 1]);
-        c_recvtypes[size - 1] = PMPI_Type_f2c(recvtypes[size - 1]);
-        --size;
+    while (outdegree > 0) {
+        c_sendtypes[outdegree - 1] = PMPI_Type_f2c(sendtypes[outdegree - 1]);
+        --outdegree;
+    }
+    while (indegree > 0) {
+        c_recvtypes[indegree - 1] = PMPI_Type_f2c(recvtypes[indegree - 1]);
+        --indegree;
     }
 
     /* Alltoallw does not support MPI_IN_PLACE */
diff --git a/ompi/mpi/fortran/use-mpi-f08/pready_list_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/pready_list_f08.F90
index f021e107cf2..78a735b2874 100644
--- a/ompi/mpi/fortran/use-mpi-f08/pready_list_f08.F90
+++ b/ompi/mpi/fortran/use-mpi-f08/pready_list_f08.F90
@@ -6,22 +6,23 @@
 ! Copyright (c) 2018      Research Organization for Information Science
 !                         and Technology (RIST).  All rights reserved.
 ! Copyright (c) 2020      Sandia National Laboratories. All rights reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 ! $COPYRIGHT$
 
 #include "mpi-f08-rename.h"
 #include "ompi/mpi/fortran/configure-fortran-output.h"
 
-subroutine MPI_Pready_list_f08(length,partitions,request,ierror)
+subroutine MPI_Pready_list_f08(length,array_of_partitions,request,ierror)
    use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request
    use :: ompi_mpifh_bindings, only : ompi_pready_list_f
    implicit none
    INTEGER, INTENT(IN) :: length
-   INTEGER, dimension(*), INTENT(IN) :: partitions
+   INTEGER, dimension(*), INTENT(IN) :: array_of_partitions
    TYPE(MPI_Request), INTENT(IN) :: request
    INTEGER, OPTIONAL, INTENT(OUT) :: ierror
    integer :: c_ierror
 
-   call ompi_pready_list_f(length,partitions,request%MPI_VAL,c_ierror)
+   call ompi_pready_list_f(length,array_of_partitions,request%MPI_VAL,c_ierror)
    if (present(ierror)) ierror = c_ierror
 
 end subroutine MPI_Pready_list_f08
diff --git a/ompi/mpi/fortran/use-mpi-f08/reduce_scatter_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/reduce_scatter_init_ts.c.in
index a9a9d02a64b..c39c8ec33e9 100644
--- a/ompi/mpi/fortran/use-mpi-f08/reduce_scatter_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/reduce_scatter_init_ts.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2019 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -74,6 +74,9 @@ PROTOTYPE VOID reduce_scatter_init(BUFFER x1, BUFFER_OUT x2,
     }
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(recvcounts, tmp_recvcounts, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 
     if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
 
diff --git a/ompi/mpi/fortran/use-mpi-f08/scatterv_init_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/scatterv_init_ts.c.in
index 046f0669336..3f0756dbb7e 100644
--- a/ompi/mpi/fortran/use-mpi-f08/scatterv_init_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/scatterv_init_ts.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015-2021 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
- * Copyright (c) 2024      Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -110,6 +110,9 @@ PROTOTYPE VOID scatterv_init(BUFFER x1, COUNT_ARRAY sendcounts,
 
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(sendcounts, tmp_sendcounts, c_request, c_ierr, idx);
     OMPI_FORTRAN_BIGCOUNT_ARRAY_CLEANUP_NONBLOCKING(displs, tmp_displs, c_request, c_ierr, idx);
+    if (idx > 0) {
+        ompi_coll_base_add_release_arrays_cb(c_request);
+    }
 
      if ((c_recvdatatype != NULL ) && (c_recvdatatype != c_recvtype)){
         ompi_datatype_destroy(&c_recvdatatype);
diff --git a/ompi/mpi/fortran/use-mpi-f08/session_attach_buffer_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/session_attach_buffer_ts.c.in
index d3550eed9b9..b5917145c5c 100644
--- a/ompi/mpi/fortran/use-mpi-f08/session_attach_buffer_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/session_attach_buffer_ts.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -30,7 +31,7 @@ PROTOTYPE VOID session_attach_buffer(SESSION session, BUFFER_ASYNC x, COUNT size
     c_session = PMPI_Session_f2c(*session);
 
     if (OMPI_CFI_IS_CONTIGUOUS(x)) {
-        c_ierr = PMPI_Session_attach_buffer(c_session, OMPI_CFI_BASE_ADDR(x), c_size);
+        c_ierr = PMPI_Session_attach_buffer(c_session, OMPI_F2C_BUFFER_AUTOMATIC(OMPI_CFI_BASE_ADDR(x)), c_size);
     } else {
         c_ierr = MPI_ERR_BUFFER;
         OMPI_ERRHANDLER_INVOKE(c_session, c_ierr, FUNC_NAME);
diff --git a/ompi/mpi/fortran/use-mpi-f08/session_detach_buffer.c.in b/ompi/mpi/fortran/use-mpi-f08/session_detach_buffer.c.in
index acaaa856386..035c8d05147 100644
--- a/ompi/mpi/fortran/use-mpi-f08/session_detach_buffer.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/session_detach_buffer.c.in
@@ -15,6 +15,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -22,7 +23,7 @@
  * $HEADER$
  */
 
-PROTOTYPE VOID session_detach_buffer(SESSION session, C_PTR_OUT buffer, COUNT size)
+PROTOTYPE VOID session_detach_buffer(SESSION session, C_PTR_OUT buffer, COUNT_OUT size)
 {
     int c_ierr;
     MPI_Session c_session;
@@ -35,7 +36,7 @@ PROTOTYPE VOID session_detach_buffer(SESSION session, C_PTR_OUT buffer, COUNT si
 
     if (MPI_SUCCESS == c_ierr) {
         *size = (@COUNT_FINT_TYPE@)(c_size);
-        if (MPI_BUFFER_AUTOMATIC == buffer) {
+        if (MPI_BUFFER_AUTOMATIC == *((void **)buffer)) {
             *((void **)buffer) = OMPI_FORTRAN_BUFFER_AUTOMATIC_ADDR();
         }
     }
diff --git a/ompi/mpi/fortran/use-mpi-f08/session_finalize_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/session_finalize_f08.F90
index ef626258f0d..64ab388d880 100644
--- a/ompi/mpi/fortran/use-mpi-f08/session_finalize_f08.F90
+++ b/ompi/mpi/fortran/use-mpi-f08/session_finalize_f08.F90
@@ -7,6 +7,7 @@
 !                         and Technology (RIST).  All rights reserved.
 ! Copyright (c) 2019      Triad National Security, LLC. All rights
 !                         reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 ! $COPYRIGHT$
 
 #include "mpi-f08-rename.h"
@@ -15,7 +16,7 @@ subroutine MPI_Session_finalize_f08(session,ierror)
    use :: mpi_f08_types, only : MPI_Session
    use :: ompi_mpifh_bindings, only : ompi_session_finalize_f
    implicit none
-   TYPE(MPI_Session), INTENT(OUT) :: session
+   TYPE(MPI_Session), INTENT(INOUT) :: session
    INTEGER, OPTIONAL, INTENT(OUT) :: ierror
    integer :: c_ierror
 
diff --git a/ompi/mpi/fortran/use-mpi-f08/session_get_info_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/session_get_info_f08.F90
index a1abe6dfdb5..34bb4d2155e 100644
--- a/ompi/mpi/fortran/use-mpi-f08/session_get_info_f08.F90
+++ b/ompi/mpi/fortran/use-mpi-f08/session_get_info_f08.F90
@@ -7,20 +7,21 @@
 !                         and Technology (RIST).  All rights reserved.
 ! Copyright (c) 2019-2022 Triad National Security, LLC. All rights
 !                         reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 ! $COPYRIGHT$
 
 #include "mpi-f08-rename.h"
 
-subroutine MPI_Session_get_info_f08(session, info, ierror)
+subroutine MPI_Session_get_info_f08(session, info_used, ierror)
    use :: mpi_f08_types, only : MPI_Session, MPI_Info
    use :: ompi_mpifh_bindings, only : ompi_session_get_info_f
    implicit none
    TYPE(MPI_Session), INTENT(IN) :: session
-   TYPE(MPI_Info), INTENT(OUT) :: info
+   TYPE(MPI_Info), INTENT(OUT) :: info_used
    INTEGER, OPTIONAL, INTENT(OUT) :: ierror
    integer :: c_ierror
 
-   call ompi_session_get_info_f(session%MPI_VAL, info%MPI_VAL, c_ierror)
+   call ompi_session_get_info_f(session%MPI_VAL, info_used%MPI_VAL, c_ierror)
    if (present(ierror)) ierror = c_ierror
 
 end subroutine MPI_Session_get_info_f08
diff --git a/ompi/mpi/fortran/use-mpi-f08/session_init_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/session_init_f08.F90
index b9eee1338b1..2f01bd4b737 100644
--- a/ompi/mpi/fortran/use-mpi-f08/session_init_f08.F90
+++ b/ompi/mpi/fortran/use-mpi-f08/session_init_f08.F90
@@ -7,6 +7,7 @@
 !                         and Technology (RIST).  All rights reserved.
 ! Copyright (c) 2019-2021 Triad National Security, LLC. All rights
 !                         reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 ! $COPYRIGHT$
 
 #include "ompi/mpi/fortran/configure-fortran-output.h"
@@ -18,7 +19,7 @@ subroutine MPI_Session_init_f08(info,errhandler,session,ierror)
    use :: ompi_mpifh_bindings, only : ompi_session_init_f
    implicit none
    TYPE(MPI_Info), INTENT(IN) :: info
-   TYPE(MPI_Errhandler), INTENT(OUT) :: errhandler
+   TYPE(MPI_Errhandler), INTENT(IN) :: errhandler
    TYPE(MPI_Session), INTENT(OUT) :: session
    INTEGER, OPTIONAL, INTENT(OUT) :: ierror
    integer :: c_ierror
diff --git a/ompi/mpi/fortran/use-mpi-f08/status_get_error.c.in b/ompi/mpi/fortran/use-mpi-f08/status_get_error.c.in
new file mode 100644
index 00000000000..317e7f7eb95
--- /dev/null
+++ b/ompi/mpi/fortran/use-mpi-f08/status_get_error.c.in
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+PROTOTYPE VOID status_get_error(STATUS status, INT_OUT err)
+{
+    int c_ierr;
+    int c_err;
+    MPI_Status c_status;
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        *err = OMPI_INT_2_FINT(0);
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = @INNER_CALL@(&c_status, &c_err);
+
+        if (MPI_SUCCESS == c_ierr) {
+            *err = OMPI_INT_2_FINT(c_err);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/use-mpi-f08/status_get_source.c.in b/ompi/mpi/fortran/use-mpi-f08/status_get_source.c.in
new file mode 100644
index 00000000000..f322fd32543
--- /dev/null
+++ b/ompi/mpi/fortran/use-mpi-f08/status_get_source.c.in
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+PROTOTYPE VOID status_get_source(STATUS status, INT_OUT source)
+{
+    int c_ierr;
+    int c_source;
+    MPI_Status c_status;
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        *source = OMPI_INT_2_FINT(0);
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = @INNER_CALL@(&c_status, &c_source);
+
+        if (MPI_SUCCESS == c_ierr) {
+            *source = OMPI_INT_2_FINT(c_source);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/use-mpi-f08/status_get_tag.c.in b/ompi/mpi/fortran/use-mpi-f08/status_get_tag.c.in
new file mode 100644
index 00000000000..3d9c3a5194d
--- /dev/null
+++ b/ompi/mpi/fortran/use-mpi-f08/status_get_tag.c.in
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+PROTOTYPE VOID status_get_tag(STATUS status, INT_OUT tag)
+{
+    int c_ierr;
+    int c_tag;
+    MPI_Status c_status;
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        *tag = OMPI_INT_2_FINT(0);
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = @INNER_CALL@(&c_status, &c_tag);
+
+        if (MPI_SUCCESS == c_ierr) {
+            *tag = OMPI_INT_2_FINT(c_tag);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/use-mpi-f08/status_set_elements.c.in b/ompi/mpi/fortran/use-mpi-f08/status_set_elements.c.in
index 0001700d391..f12eab26ca4 100644
--- a/ompi/mpi/fortran/use-mpi-f08/status_set_elements.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/status_set_elements.c.in
@@ -12,7 +12,7 @@
  * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -21,7 +21,7 @@
  * $HEADER$
  */
 
-PROTOTYPE VOID status_set_elements(STATUS status, DATATYPE datatype,
+PROTOTYPE VOID status_set_elements(STATUS_INOUT status, DATATYPE datatype,
 			           COUNT count)
 {
     int c_ierr;
@@ -38,8 +38,6 @@ PROTOTYPE VOID status_set_elements(STATUS status, DATATYPE datatype,
 
         c_ierr = @INNER_CALL@(&c_status, c_type, c_count);
 
-        /* If datatype is really being set, then that needs to be
-           converted.... */
         if (MPI_SUCCESS == c_ierr) {
             PMPI_Status_c2f(&c_status, status);
         }
diff --git a/ompi/mpi/fortran/use-mpi-f08/status_set_error.c.in b/ompi/mpi/fortran/use-mpi-f08/status_set_error.c.in
new file mode 100644
index 00000000000..7d4658a564f
--- /dev/null
+++ b/ompi/mpi/fortran/use-mpi-f08/status_set_error.c.in
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+PROTOTYPE VOID status_set_error(STATUS_INOUT status, INT err)
+{
+    int c_ierr;
+    MPI_Status c_status;
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = @INNER_CALL@(&c_status, OMPI_FINT_2_INT(*err));
+
+        if (MPI_SUCCESS == c_ierr) {
+            PMPI_Status_c2f(&c_status, status);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/use-mpi-f08/status_set_source.c.in b/ompi/mpi/fortran/use-mpi-f08/status_set_source.c.in
new file mode 100644
index 00000000000..60fe2f22dd9
--- /dev/null
+++ b/ompi/mpi/fortran/use-mpi-f08/status_set_source.c.in
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+PROTOTYPE VOID status_set_source(STATUS_INOUT status, INT source)
+{
+    int c_ierr;
+    MPI_Status c_status;
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = @INNER_CALL@(&c_status, OMPI_FINT_2_INT(*source));
+
+        if (MPI_SUCCESS == c_ierr) {
+            PMPI_Status_c2f(&c_status, status);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/use-mpi-f08/status_set_tag.c.in b/ompi/mpi/fortran/use-mpi-f08/status_set_tag.c.in
new file mode 100644
index 00000000000..373c17b9653
--- /dev/null
+++ b/ompi/mpi/fortran/use-mpi-f08/status_set_tag.c.in
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2011-2012 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2015      Research Organization for Information Science
+ *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2024-2026 Triad National Security, LLC. All rights
+ *                         reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+PROTOTYPE VOID status_set_tag(STATUS_INOUT status, INT tag)
+{
+    int c_ierr;
+    MPI_Status c_status;
+
+    if (OMPI_IS_FORTRAN_STATUS_IGNORE(status)) {
+        c_ierr = MPI_SUCCESS;
+    } else {
+        PMPI_Status_f2c( status, &c_status );
+
+        c_ierr = @INNER_CALL@(&c_status, OMPI_FINT_2_INT(*tag));
+
+        if (MPI_SUCCESS == c_ierr) {
+            PMPI_Status_c2f(&c_status, status);
+        }
+    }
+    if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr);
+}
diff --git a/ompi/mpi/fortran/use-mpi-f08/testany.c.in b/ompi/mpi/fortran/use-mpi-f08/testany.c.in
index 3ca6be546d4..00be762e1ca 100644
--- a/ompi/mpi/fortran/use-mpi-f08/testany.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/testany.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -21,7 +22,7 @@
  * $HEADER$
  */
 
-PROTOTYPE VOID testany(INT count, REQUEST_ARRAY_INOUT array_of_requests:count, INT indx,
+PROTOTYPE VOID testany(INT count, REQUEST_ARRAY_INOUT array_of_requests:count, INDEX_OUT indx,
                        LOGICAL_OUT flag, STATUS_OUT status)
 {
     MPI_Request *c_req;
diff --git a/ompi/mpi/fortran/use-mpi-f08/type_size.c.in b/ompi/mpi/fortran/use-mpi-f08/type_size.c.in
index c71e3f9294d..b98f45ed141 100644
--- a/ompi/mpi/fortran/use-mpi-f08/type_size.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/type_size.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -21,7 +22,7 @@
  * $HEADER$
  */
 
-PROTOTYPE VOID type_size(DATATYPE type, COUNT size)
+PROTOTYPE VOID type_size(DATATYPE type, COUNT_OUT size)
 {
     int c_ierr;
     MPI_Datatype c_type = PMPI_Type_f2c(*type);
diff --git a/ompi/mpi/fortran/use-mpi-f08/unpack_external_ts.c.in b/ompi/mpi/fortran/use-mpi-f08/unpack_external_ts.c.in
index 4852a43bada..6c7ce0ff446 100644
--- a/ompi/mpi/fortran/use-mpi-f08/unpack_external_ts.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/unpack_external_ts.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -23,7 +24,7 @@
 
 PROTOTYPE VOID unpack_external(CHAR_ARRAY datarep, BUFFER x1, AINT_COUNT insize,
                                AINT_COUNT_INOUT position, BUFFER x2,
-                               COUNT_OUT outcount,  DATATYPE datatype)
+                               COUNT outcount,  DATATYPE datatype)
 {
     int c_ierr;
     MPI_Datatype c_datatype, c_type = PMPI_Type_f2c(*datatype);
diff --git a/ompi/mpi/fortran/use-mpi-f08/win_allocate_shared.c.in b/ompi/mpi/fortran/use-mpi-f08/win_allocate_shared.c.in
index ff13c22d178..4c6ca8de1b7 100644
--- a/ompi/mpi/fortran/use-mpi-f08/win_allocate_shared.c.in
+++ b/ompi/mpi/fortran/use-mpi-f08/win_allocate_shared.c.in
@@ -14,6 +14,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2024-2025 Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -23,7 +24,7 @@
 
 PROTOTYPE VOID win_allocate_shared(AINT size, DISP disp_unit,
                                    INFO info, COMM comm, C_PTR_OUT baseptr,
-                                   WIN win)
+                                   WIN_OUT win)
 {
     int c_ierr;
     MPI_Info c_info;
diff --git a/ompi/mpi/fortran/use-mpi-f08/win_get_info_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/win_get_info_f08.F90
index 23c5387e772..1bdc73bf19c 100644
--- a/ompi/mpi/fortran/use-mpi-f08/win_get_info_f08.F90
+++ b/ompi/mpi/fortran/use-mpi-f08/win_get_info_f08.F90
@@ -2,20 +2,21 @@
 !
 ! Copyright (c) 2015-2020 Research Organization for Information Science
 !                         and Technology (RIST).  All rights reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 ! $COPYRIGHT$
 
 #include "mpi-f08-rename.h"
 
-subroutine MPI_Win_get_info_f08(win,info,ierror)
+subroutine MPI_Win_get_info_f08(win,info_used,ierror)
    use :: mpi_f08_types, only : MPI_Win, MPI_Info
    use :: ompi_mpifh_bindings, only : ompi_win_get_info_f
    implicit none
    TYPE(MPI_Win), INTENT(IN) :: win
-   TYPE(MPI_Info), INTENT(OUT) :: info
+   TYPE(MPI_Info), INTENT(OUT) :: info_used
    INTEGER, OPTIONAL, INTENT(OUT) :: ierror
    integer :: c_ierror
 
-   call ompi_win_get_info_f(win%MPI_VAL,info%MPI_VAL,c_ierror)
+   call ompi_win_get_info_f(win%MPI_VAL,info_used%MPI_VAL,c_ierror)
    if (present(ierror)) ierror = c_ierror
 
 end subroutine MPI_Win_get_info_f08
diff --git a/ompi/mpi/fortran/use-mpi-ignore-tkr/Makefile.prototype_files b/ompi/mpi/fortran/use-mpi-ignore-tkr/Makefile.prototype_files
index 03f7fe313c9..546948fe5c8 100644
--- a/ompi/mpi/fortran/use-mpi-ignore-tkr/Makefile.prototype_files
+++ b/ompi/mpi/fortran/use-mpi-ignore-tkr/Makefile.prototype_files
@@ -18,4 +18,11 @@ prototype_files = \
         session_detach_buffer.c.in \
         session_flush_buffer.c.in \
         session_iflush_buffer.c.in \
+        status_get_error.c.in \
+        status_get_source.c.in \
+        status_get_tag.c.in \
+        status_set_elements.c.in \
+        status_set_error.c.in \
+        status_set_source.c.in \
+        status_set_tag.c.in \
         type_get_value_index.c.in
diff --git a/ompi/mpi/fortran/use-mpi-ignore-tkr/mpi-ignore-tkr-interfaces.h.in b/ompi/mpi/fortran/use-mpi-ignore-tkr/mpi-ignore-tkr-interfaces.h.in
index 187fcbcf245..57733a1db94 100644
--- a/ompi/mpi/fortran/use-mpi-ignore-tkr/mpi-ignore-tkr-interfaces.h.in
+++ b/ompi/mpi/fortran/use-mpi-ignore-tkr/mpi-ignore-tkr-interfaces.h.in
@@ -3747,15 +3747,14 @@ subroutine MPI_Session_get_nth_pset(session, info, n, pset_len, pset_name, ierro
 end subroutine MPI_Session_get_nth_pset
 end interface
 
-interface MPI_Session_get_nth_psetlen
-subroutine MPI_Session_get_nth_psetlen(session, n, pset_len, ierror)
-   implicit none
+interface MPI_Session_get_num_psets
+subroutine MPI_Session_get_num_psets(session, info, npset_names, ierror)
    integer, INTENT(IN) :: session
-   INTEGER, INTENT(IN) :: n
-   INTEGER, INTENT(OUT) :: pset_len
+   integer, INTENT(IN) :: info
+   INTEGER, INTENT(OUT) :: npset_names
    INTEGER, INTENT(OUT) :: ierror
-end subroutine MPI_Session_get_nth_psetlen
-end interface 
+end subroutine MPI_Session_get_num_psets
+end interface
 
 interface MPI_Session_get_pset_info
 subroutine MPI_Session_get_pset_info(session, pset_name, info, ierror)
@@ -3862,19 +3861,6 @@ end subroutine MPI_Status_set_cancelled
 end interface
 
 
-interface
-
-subroutine MPI_Status_set_elements(status, datatype, count, ierror)
-  include 'mpif-config.h'
-  integer, dimension(MPI_STATUS_SIZE), intent(inout) :: status
-  integer, intent(in) :: datatype
-  integer, intent(in) :: count
-  integer, intent(out) :: ierror
-end subroutine MPI_Status_set_elements
-
-end interface
-
-
 interface
 
 subroutine MPI_Status_set_elements_x(status, datatype, count, ierror)
diff --git a/ompi/mpi/fortran/use-mpi-ignore-tkr/pmpi-ignore-tkr-interfaces.h b/ompi/mpi/fortran/use-mpi-ignore-tkr/pmpi-ignore-tkr-interfaces.h
index 358e882538c..cb238ef68cf 100644
--- a/ompi/mpi/fortran/use-mpi-ignore-tkr/pmpi-ignore-tkr-interfaces.h
+++ b/ompi/mpi/fortran/use-mpi-ignore-tkr/pmpi-ignore-tkr-interfaces.h
@@ -252,7 +252,7 @@
 #define MPI_Session_get_errhandler PMPI_Session_get_errhandler
 #define MPI_Session_get_info PMPI_Session_get_info
 #define MPI_Session_get_nth_pset PMPI_Session_get_nth_pset
-#define MPI_Session_get_nth_psetlen PMPI_Session_get_nth_psetlen
+#define MPI_Session_get_num_psets PMPI_Session_get_num_psets
 #define MPI_Session_get_pset_info PMPI_Session_get_pset_info
 #define MPI_Session_init PMPI_Session_init
 #define MPI_Session_finalize PMPI_Session_finalize
diff --git a/ompi/mpi/java/Makefile.am b/ompi/mpi/java/Makefile.am
deleted file mode 100644
index 943f3ecc757..00000000000
--- a/ompi/mpi/java/Makefile.am
+++ /dev/null
@@ -1,14 +0,0 @@
-# -*- makefile -*-
-#
-# Copyright (c) 2011      Cisco Systems, Inc.  All rights reserved.
-# Copyright (c) 2014      Intel, Inc. All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-SUBDIRS = java c
-
-EXTRA_DIST = README.md
diff --git a/ompi/mpi/java/README.md b/ompi/mpi/java/README.md
deleted file mode 100644
index 93b43d3521a..00000000000
--- a/ompi/mpi/java/README.md
+++ /dev/null
@@ -1,55 +0,0 @@
-# Open MPI Java bindings
-
-Note about the Open MPI Java bindings
-
-The Java bindings in this directory are not part of the MPI
-specification, as noted in the README.JAVA.md file in the root
-directory. That file also contains some information regarding the
-installation and use of the Java bindings. Further details can be
-found in the paper [1].
-
-We originally took the code from the mpiJava project [2] as starting point
-for our developments, but we have pretty much rewritten 100% of it. The
-original copyrights and license terms of mpiJava are listed below.
-
-1. O. Vega-Gisbert, J. E. Roman, and J. M. Squyres. "Design and
-   implementation of Java bindings in Open MPI". Parallel Comput.
-   59: 1-20 (2016).
-1. M. Baker et al. "mpiJava: An object-oriented Java interface to
-   MPI". In Parallel and Distributed Processing, LNCS vol. 1586,
-   pp. 748-762, Springer (1999).
-
-## Original citation
-
-```
-            mpiJava - A Java Interface to MPI
-            ---------------------------------
-                    Copyright 2003
-
-        Bryan Carpenter, Sung Hoon Ko, Sang Boem Lim
-        Pervasive Technology Labs, Indiana University
-        email {shko,slim,dbc}@grids.ucs.indiana.edu
-
-                       Xinying Li
-                   Syracuse University
-
-                       Mark Baker
-             CSM, University of Portsmouth
-             email mark.baker@computer.org
-
-      (Bugfixes/Additions, CMake based configure/build)
-                      Blasius Czink
-               HLRS, University of Stuttgart
-```
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-   http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/ompi/mpi/java/c/Makefile.am b/ompi/mpi/java/c/Makefile.am
deleted file mode 100644
index 96552eb93e0..00000000000
--- a/ompi/mpi/java/c/Makefile.am
+++ /dev/null
@@ -1,53 +0,0 @@
-# -*- makefile -*-
-#
-# Copyright (c) 2011-2018 Cisco Systems, Inc.  All rights reserved
-# Copyright (c) 2012      Oracle and/or its affiliates.  All rights reserved.
-# Copyright (c) 2015      Los Alamos National Security, LLC. All rights
-#                         reserved.
-# Copyright (c) 2015      Research Organization for Information Science
-#                         and Technology (RIST). All rights reserved.
-# Copyright (c) 2016      IBM Corporation.  All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-if OMPI_WANT_JAVA_BINDINGS
-
-# Get the include files that were generated from the .java source files
-AM_CPPFLAGS = -I$(top_builddir)/ompi/mpi/java/java $(OMPI_JDK_CPPFLAGS) -DOMPI_LIBMPI_NAME=\"$(OMPI_LIBMPI_NAME)\" -DOPAL_DYN_LIB_SUFFIX=\"$(OPAL_DYN_LIB_SUFFIX)\"
-
-headers = \
-        mpiJava.h
-ompidir = $(ompiincludedir)/ompi/mpi/java
-ompi_HEADERS = \
-        $(headers)
-
-lib_LTLIBRARIES = lib@OMPI_LIBMPI_NAME@_java.la
-lib@OMPI_LIBMPI_NAME@_java_la_SOURCES = \
-	mpi_CartComm.c \
-	mpi_Comm.c \
-	mpi_Constant.c \
-	mpi_Count.c   \
-	mpi_Datatype.c \
-	mpi_Errhandler.c \
-	mpi_File.c \
-	mpi_GraphComm.c \
-	mpi_Group.c \
-	mpi_Info.c \
-	mpi_Intercomm.c \
-	mpi_Intracomm.c \
-	mpi_Message.c \
-	mpi_MPI.c \
-	mpi_Op.c \
-	mpi_Request.c \
-	mpi_Prequest.c \
-	mpi_Status.c \
-	mpi_Win.c
-
-lib@OMPI_LIBMPI_NAME@_java_la_LIBADD = -ldl $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la
-lib@OMPI_LIBMPI_NAME@_java_la_LDFLAGS = -version-info $(libmpi_java_so_version)
-
-endif
diff --git a/ompi/mpi/java/c/mpiJava.h b/ompi/mpi/java/c/mpiJava.h
deleted file mode 100644
index 319536e22d4..00000000000
--- a/ompi/mpi/java/c/mpiJava.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2019       FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#ifndef _MPIJAVA_H_
-#define _MPIJAVA_H_
-
-#include "mpi.h"
-#include "opal/class/opal_free_list.h"
-
-typedef struct {
-    jfieldID  CommHandle;
-    jfieldID  GroupHandle;
-    jclass    CartParmsClass;
-    jmethodID CartParmsInit;
-    jclass    ShiftParmsClass;
-    jmethodID ShiftParmsInit;
-    jclass    VersionClass;
-    jmethodID VersionInit;
-    jclass    CountClass;
-    jmethodID CountInit;
-    jclass    GraphParmsClass;
-    jmethodID GraphParmsInit;
-    jclass    DistGraphNeighborsClass;
-    jmethodID DistGraphNeighborsInit;
-    jfieldID  DatatypeHandle;
-    jfieldID  DatatypeBaseType;
-    jfieldID  DatatypeBaseSize;
-    jfieldID  MessageHandle;
-    jfieldID  OpHandle;
-    jfieldID  OpCommute;
-    jmethodID OpCall;
-    jfieldID  ReqHandle;
-    jclass    StatusClass;
-    jfieldID  StatusData;
-    jclass    ExceptionClass;
-    jmethodID ExceptionInit;
-    jclass    IntegerClass;
-    jmethodID IntegerValueOf;
-    jclass    LongClass;
-    jmethodID LongValueOf;
-} ompi_java_globals_t;
-
-extern ompi_java_globals_t ompi_java;
-
-typedef struct ompi_java_buffer_t
-{
-    opal_free_list_item_t super;
-    void *buffer;
-} ompi_java_buffer_t;
-
-OMPI_DECLSPEC OBJ_CLASS_DECLARATION(ompi_java_buffer_t);
-
-void* ompi_java_getArrayCritical(void** bufBase, JNIEnv *env,
-                                 jobject buf, int offset);
-
-void* ompi_java_getDirectBufferAddress(JNIEnv *env, jobject buf);
-
-/* Gets a buffer pointer for reading (copy from Java). */
-void ompi_java_getReadPtr(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        jboolean db, int offset, int count, MPI_Datatype type, int baseType);
-
-/* Gets a buffer pointer for reading.
- * It only copies from java the rank data.
- * 'size' is the number of processes. */
-void ompi_java_getReadPtrRank(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int offset, int count, int size,
-        int rank, MPI_Datatype type, int baseType);
-
-/* Gets a buffer pointer for reading, but it
- * 'size' is the number of processes.
- * if rank == -1 it copies all data from Java.
- * if rank != -1 it only copies from Java the rank data. */
-void ompi_java_getReadPtrv(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int off, int *counts, int *displs,
-        int size, int rank, MPI_Datatype type, int baseType);
-
-/* Gets a buffer pointer for reading, but it
- * 'size' is the number of processes.
- * if rank == -1 it copies all data from Java.
- * if rank != -1 it only copies from Java the rank data. */
-void ompi_java_getReadPtrw(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int *offs, int *counts, int *displs,
-        int size, int rank, MPI_Datatype *types, int *baseTypes);
-
-/* Releases a buffer used for reading. */
-void ompi_java_releaseReadPtr(
-        void *ptr, ompi_java_buffer_t *item, jobject buf, jboolean db);
-
-/* Gets a buffer pointer for writing. */
-void ompi_java_getWritePtr(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int count, MPI_Datatype type);
-
-/* Gets a buffer pointer for writing.
- * 'size' is the number of processes. */
-void ompi_java_getWritePtrv(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        jboolean db, int *counts, int *displs, int size, MPI_Datatype type);
-
-/* Gets a buffer pointer for writing.
- * 'size' is the number of processes. */
-void ompi_java_getWritePtrw(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        jboolean db, int *counts, int *displs, int size, MPI_Datatype *types);
-
-/* Releases a buffer used for writing.
- * It copies data to Java. */
-void ompi_java_releaseWritePtr(
-        void *ptr, ompi_java_buffer_t *item, JNIEnv *env, jobject buf,
-        jboolean db, int offset, int count, MPI_Datatype type, int baseType);
-
-/* Releases a buffer used for writing.
- * It copies data to Java.
- * 'size' is the number of processes. */
-void ompi_java_releaseWritePtrv(
-        void *ptr, ompi_java_buffer_t *item, JNIEnv *env,
-        jobject buf, jboolean db, int off, int *counts, int *displs,
-        int size, MPI_Datatype type, int baseType);
-
-/* Releases a buffer used for writing.
- * It copies data to Java.
- * 'size' is the number of processes. */
-void ompi_java_releaseWritePtrw(
-        void *ptr, ompi_java_buffer_t *item, JNIEnv *env,
-        jobject buf, jboolean db, int *offs, int *counts, int *displs,
-        int size, MPI_Datatype *types, int *baseTypes);
-
-void ompi_java_setStaticLongField(JNIEnv *env, jclass c,
-                                  char *field, jlong value);
-
-void ompi_java_setIntField(JNIEnv *env, jclass c, jobject obj,
-                           char *field, jint value);
-
-jobject ompi_java_Integer_valueOf(JNIEnv *env, jint i);
-jobject ompi_java_Long_valueOf(JNIEnv *env, jlong i);
-
-void ompi_java_getIntArray(
-        JNIEnv *env, jintArray array, jint **jptr, int **cptr);
-void ompi_java_releaseIntArray(
-        JNIEnv *env, jintArray array, jint *jptr, int *cptr);
-void ompi_java_forgetIntArray(
-        JNIEnv *env, jintArray array, jint *jptr, int *cptr);
-
-void ompi_java_getDatatypeArray(
-        JNIEnv *env, jlongArray array, jlong **jptr, MPI_Datatype **cptr);
-void ompi_java_forgetDatatypeArray(
-        JNIEnv *env, jlongArray array, jlong *jptr, MPI_Datatype *cptr);
-
-void ompi_java_getBooleanArray(
-        JNIEnv *env, jbooleanArray array, jboolean **jptr, int **cptr);
-void ompi_java_releaseBooleanArray(
-        JNIEnv *env, jbooleanArray array, jboolean *jptr, int *cptr);
-void ompi_java_forgetBooleanArray(
-        JNIEnv *env, jbooleanArray array, jboolean *jptr, int *cptr);
-
-void ompi_java_getPtrArray(
-        JNIEnv *env, jlongArray array, jlong **jptr, void ***cptr);
-void ompi_java_releasePtrArray(
-        JNIEnv *env, jlongArray array, jlong *jptr, void **cptr);
-
-jboolean ompi_java_exceptionCheck(JNIEnv *env, int rc);
-
-void*      ompi_java_attrSet(JNIEnv *env, jbyteArray jval);
-jbyteArray ompi_java_attrGet(JNIEnv *env, void *cval);
-int        ompi_java_attrCopy(void *attrValIn, void *attrValOut, int *flag);
-int        ompi_java_attrDelete(void *attrVal);
-
-MPI_Op ompi_java_op_getHandle(
-        JNIEnv *env, jobject jOp, jlong hOp, int baseType);
-
-jobject ompi_java_status_new(JNIEnv *env, MPI_Status *status);
-jobject ompi_java_status_newIndex(JNIEnv *env, MPI_Status *status, int index);
-
-void ompi_java_status_set(
-        JNIEnv *env, jlongArray jData, MPI_Status *status);
-void ompi_java_status_setIndex(
-        JNIEnv *env, jlongArray jData, MPI_Status *status, int index);
-
-#endif /* _MPIJAVA_H_ */
diff --git a/ompi/mpi/java/c/mpi_CartComm.c b/ompi/mpi/java/c/mpi_CartComm.c
deleted file mode 100644
index 9c6a8b3040f..00000000000
--- a/ompi/mpi/java/c/mpi_CartComm.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_CartComm.c
- * Headerfile   : mpi_CartComm.h
- * Author       : Sung-Hoon Ko, Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.6 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_CartComm.h"
-#include "mpiJava.h"
-
-JNIEXPORT void JNICALL Java_mpi_CartComm_init(JNIEnv *env, jclass clazz)
-{
-    ompi_java.CartParmsInit = (*env)->GetMethodID(env,
-            ompi_java.CartParmsClass, "<init>", "([I[Z[I)V");
-
-    ompi_java.ShiftParmsInit = (*env)->GetMethodID(env,
-            ompi_java.ShiftParmsClass, "<init>", "(II)V");
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_CartComm_getTopo(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    int maxdims;
-    int rc = MPI_Cartdim_get((MPI_Comm)comm, &maxdims);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    jintArray     dims    = (*env)->NewIntArray(env, maxdims);
-    jbooleanArray periods = (*env)->NewBooleanArray(env, maxdims);
-    jintArray     coords  = (*env)->NewIntArray(env, maxdims);
-
-    if(maxdims != 0)
-    {
-        jint *jDims, *jCoords;
-        jboolean *jPeriods;
-        int  *cDims, *cCoords, *cPeriods;
-
-        ompi_java_getIntArray(env, dims, &jDims, &cDims);
-        ompi_java_getIntArray(env, coords, &jCoords, &cCoords);
-        ompi_java_getBooleanArray(env, periods, &jPeriods, &cPeriods);
-
-        rc = MPI_Cart_get((MPI_Comm)comm, maxdims, cDims, cPeriods, cCoords);
-        ompi_java_exceptionCheck(env, rc);
-
-        ompi_java_releaseIntArray(env, dims, jDims, cDims);
-        ompi_java_releaseIntArray(env, coords, jCoords, cCoords);
-        ompi_java_releaseBooleanArray(env, periods, jPeriods, cPeriods);
-    }
-
-    return (*env)->NewObject(env, ompi_java.CartParmsClass,
-                             ompi_java.CartParmsInit, dims, periods, coords);
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_CartComm_shift(
-        JNIEnv *env, jobject jthis, jlong comm, jint direction, jint disp)
-{
-    int sr, dr;
-    int rc = MPI_Cart_shift((MPI_Comm)comm, direction, disp, &sr, &dr);
-    ompi_java_exceptionCheck(env, rc);
-
-    return (*env)->NewObject(env, ompi_java.ShiftParmsClass,
-                             ompi_java.ShiftParmsInit, sr, dr);
-}
-
-JNIEXPORT jintArray JNICALL Java_mpi_CartComm_getCoords(
-        JNIEnv *env, jobject jthis, jlong comm, jint rank)
-{
-    int maxdims;
-    int rc = MPI_Cartdim_get((MPI_Comm)comm, &maxdims);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    jintArray coords = (*env)->NewIntArray(env, maxdims);
-    jint *jCoords;
-    int  *cCoords;
-    ompi_java_getIntArray(env, coords, &jCoords, &cCoords);
-
-    rc = MPI_Cart_coords((MPI_Comm)comm, rank, maxdims, cCoords);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseIntArray(env, coords, jCoords, cCoords);
-    return coords;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_CartComm_map(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jintArray dims, jbooleanArray periods)
-{
-    int nDims = (*env)->GetArrayLength(env, dims);
-    jint *jDims;
-    jboolean *jPeriods;
-    int *cDims, *cPeriods;
-    ompi_java_getIntArray(env, dims, &jDims, &cDims);
-    ompi_java_getBooleanArray(env, periods, &jPeriods, &cPeriods);
-
-    int newrank;
-    int rc = MPI_Cart_map((MPI_Comm)comm, nDims, cDims, cPeriods, &newrank);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_forgetIntArray(env, dims, jDims, cDims);
-    ompi_java_forgetBooleanArray(env, periods, jPeriods, cPeriods);
-    return newrank;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_CartComm_getRank(
-        JNIEnv *env, jobject jthis, jlong comm, jintArray coords)
-{
-    jint *jCoords;
-    int  *cCoords;
-    ompi_java_getIntArray(env, coords, &jCoords, &cCoords);
-
-    int rank;
-    int rc = MPI_Cart_rank((MPI_Comm)comm, cCoords, &rank);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_forgetIntArray(env, coords, jCoords, cCoords);
-    return rank;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_CartComm_sub(
-        JNIEnv *env, jobject jthis, jlong comm, jbooleanArray remainDims)
-{
-    jboolean *jRemainDims;
-    int      *cRemainDims;
-    ompi_java_getBooleanArray(env, remainDims, &jRemainDims, &cRemainDims);
-
-    MPI_Comm newcomm;
-    int rc = MPI_Cart_sub((MPI_Comm)comm, cRemainDims, &newcomm);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_forgetBooleanArray(env, remainDims, jRemainDims, cRemainDims);
-    return (jlong)newcomm;
-}
-
-JNIEXPORT void JNICALL Java_mpi_CartComm_createDims_1jni(
-        JNIEnv *env, jclass jthis, jint nNodes, jintArray dims)
-{
-    int   nDims = (*env)->GetArrayLength(env, dims);
-    jint *jDims;
-    int  *cDims;
-    ompi_java_getIntArray(env, dims, &jDims, &cDims);
-
-    int rc = MPI_Dims_create(nNodes, nDims, cDims);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseIntArray(env, dims, jDims, cDims);
-}
diff --git a/ompi/mpi/java/c/mpi_Comm.c b/ompi/mpi/java/c/mpi_Comm.c
deleted file mode 100644
index f31f210037a..00000000000
--- a/ompi/mpi/java/c/mpi_Comm.c
+++ /dev/null
@@ -1,2294 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015-2018 Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2016      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2017-2019 FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_Comm.c
- * Headerfile   : mpi_Comm.h
- * Author       : Sung-Hoon Ko, Xinying Li, Sang Lim, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.17 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-#include "ompi_config.h"
-#include <stdlib.h>
-#include <assert.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Comm.h"
-#include "mpiJava.h"  /* must come AFTER the related .h so JNI is included */
-
-static void* getBufCritical(void** bufBase, JNIEnv *env,
-                            jobject buf, jboolean db, int offset)
-{
-    if(buf == NULL)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *bufBase = NULL;
-        return NULL;
-    }
-    else if(db)
-    {
-        *bufBase = (*env)->GetDirectBufferAddress(env, buf);
-        assert(offset == 0);
-        return *bufBase;
-    }
-    else
-    {
-        return ompi_java_getArrayCritical(bufBase, env, buf, offset);
-    }
-}
-
-static void releaseBufCritical(
-        JNIEnv *env, jobject buf, jboolean db, void* bufBase)
-{
-    if(!db && buf)
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, 0);
-}
-
-static int isInter(JNIEnv *env, MPI_Comm comm)
-{
-    int rc, flag;
-    rc = MPI_Comm_test_inter(comm, &flag);
-    ompi_java_exceptionCheck(env, rc);
-    return flag;
-}
-
-static int getSize(JNIEnv *env, MPI_Comm comm, int inter)
-{
-    int rc, size;
-
-    if(inter)
-        rc = MPI_Comm_remote_size(comm, &size);
-    else
-        rc = MPI_Comm_size(comm, &size);
-
-    ompi_java_exceptionCheck(env, rc);
-    return size;
-}
-
-static int getGroupSize(JNIEnv *env, MPI_Comm comm)
-{
-    int rc, size;
-    rc = MPI_Comm_size(comm, &size);
-    ompi_java_exceptionCheck(env, rc);
-    return size;
-}
-
-static int getRank(JNIEnv *env, MPI_Comm comm)
-{
-    int rc, rank;
-    rc = MPI_Comm_rank(comm, &rank);
-    ompi_java_exceptionCheck(env, rc);
-    return rank;
-}
-
-static int getTopo(JNIEnv *env, MPI_Comm comm)
-{
-    int rc, status;
-    rc = MPI_Topo_test(comm, &status);
-    ompi_java_exceptionCheck(env, rc);
-    return status;
-}
-
-static void getNeighbors(JNIEnv *env, MPI_Comm comm, int *out, int *in)
-{
-    int rc, weighted;
-
-    switch(getTopo(env, comm))
-    {
-        case MPI_CART:
-            rc = MPI_Cartdim_get(comm, in);
-            *in *= 2;
-            *out = *in;
-            break;
-        case MPI_GRAPH:
-            rc = MPI_Graph_neighbors_count(comm, getRank(env, comm), in);
-            *out = *in;
-            break;
-        case MPI_DIST_GRAPH:
-            rc = MPI_Dist_graph_neighbors_count(comm, in, out, &weighted);
-            break;
-        default:
-            rc = MPI_ERR_TOPOLOGY;
-            break;
-    }
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-static int getSum(int *counts, int size)
-{
-    int i, s = 0;
-
-    for(i = 0; i < size; i++)
-        s += counts[i];
-
-    return s;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_init(JNIEnv *env, jclass clazz)
-{
-    jfieldID nullHandleID = (*env)->GetStaticFieldID(
-                            env, clazz, "nullHandle", "J");
-
-    (*env)->SetStaticLongField(env, clazz, nullHandleID, (jlong)MPI_COMM_NULL);
-    ompi_java.CommHandle = (*env)->GetFieldID(env,clazz,"handle","J");
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_getComm(JNIEnv *env, jobject jthis,
-                                             jint type)
-{
-    switch (type) {
-    case 0:
-        (*env)->SetLongField(env,jthis, ompi_java.CommHandle,(jlong)MPI_COMM_NULL);
-        break;
-    case 1:
-        (*env)->SetLongField(env,jthis, ompi_java.CommHandle,(jlong)MPI_COMM_SELF);
-        break;
-    case 2:
-        (*env)->SetLongField(env,jthis, ompi_java.CommHandle,(jlong)MPI_COMM_WORLD);
-        break;
-    }
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_dup(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    MPI_Comm newcomm;
-    int rc = MPI_Comm_dup((MPI_Comm)comm, &newcomm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newcomm;
-}
-
-JNIEXPORT jlongArray JNICALL Java_mpi_Comm_iDup(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    MPI_Comm newcomm;
-    MPI_Request request;
-    int rc = MPI_Comm_idup((MPI_Comm)comm, &newcomm, &request);
-    
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-    
-    jlongArray jcr = (*env)->NewLongArray(env, 2);
-    jlong *cr = (jlong*)(*env)->GetPrimitiveArrayCritical(env, jcr, NULL);
-    cr[0] = (jlong)newcomm;
-    cr[1] = (jlong)request;
-    (*env)->ReleasePrimitiveArrayCritical(env, jcr, cr, 0);
-    return jcr;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_dupWithInfo(
-        JNIEnv *env, jobject jthis, jlong comm, jlong info)
-{
-    MPI_Comm newcomm;
-    int rc = MPI_Comm_dup_with_info((MPI_Comm)comm, (MPI_Info)info, &newcomm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newcomm;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_getSize(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    int rc, size;
-    rc = MPI_Comm_size((MPI_Comm)comm, &size);
-    ompi_java_exceptionCheck(env, rc);
-    return size;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_getRank(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    return getRank(env, (MPI_Comm)comm);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_compare(
-        JNIEnv *env, jclass jthis, jlong comm1, jlong comm2)
-{
-    int rc, result;
-    rc = MPI_Comm_compare((MPI_Comm)comm1, (MPI_Comm)comm2, &result);
-    ompi_java_exceptionCheck(env, rc);
-    return result;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_free(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Comm comm = (MPI_Comm)handle;
-    int rc = MPI_Comm_free(&comm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)comm;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_setInfo(
-        JNIEnv *env, jobject jthis, jlong comm, jlong info)
-{
-    int rc = MPI_Comm_set_info((MPI_Comm)comm, (MPI_Info)info);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_getInfo(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    MPI_Info info;
-    int rc = MPI_Comm_get_info((MPI_Comm)comm, &info);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)info;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_disconnect(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Comm comm = (MPI_Comm)handle;
-    int rc = MPI_Comm_disconnect(&comm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)comm;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_getGroup(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    MPI_Group group;
-    int rc = MPI_Comm_group((MPI_Comm)comm, &group);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)group;
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_Comm_isInter(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    return isInter(env, (MPI_Comm)comm) ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_createIntercomm(
-        JNIEnv *env, jobject jthis, jlong comm, jlong localComm,
-        jint localLeader, jint remoteLeader, jint tag)
-{
-    MPI_Comm newintercomm;
-
-    int rc = MPI_Intercomm_create(
-             (MPI_Comm)localComm, localLeader,
-             (MPI_Comm)comm, remoteLeader, tag, &newintercomm);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newintercomm;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_send(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject buf, jboolean db, jint offset, jint count,
-        jlong jType, jint bType, jint dest, jint tag)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
-
-    int rc = MPI_Send(ptr, count, type, dest, tag, comm);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_recv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject buf, jboolean db, jint offset, jint count,
-        jlong jType, jint bType, jint source, jint tag, jlongArray jStatus)
-{
-    jboolean exception;
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-
-    MPI_Status status;
-    int rc = MPI_Recv(ptr, count, type, source, tag, comm, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseWritePtr(ptr,item,env,buf,db,offset,count,type,bType);
-    
-    if(!exception)
-        ompi_java_status_set(env, jStatus, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_sendRecv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff, jint sCount,
-        jlong sjType, jint sBType, jint dest, jint sTag,
-        jobject rBuf, jboolean rdb, jint rOff, jint rCount,
-        jlong rjType, jint rBType, jint source, jint rTag,
-        jlongArray jStatus)
-{
-    jboolean exception;
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-    MPI_Status status;
-
-    ompi_java_getReadPtr(&sPtr,&sItem, env, sBuf,sdb,sOff,sCount,sType,sBType);
-    ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rCount, rType);
-
-    int rc = MPI_Sendrecv(sPtr, sCount, sType, dest, sTag,
-                          rPtr, rCount, rType, source, rTag, comm, &status);
-
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rCount,rType,rBType);
-    
-    if(!exception)
-        ompi_java_status_set(env, jStatus, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_sendRecvReplace(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject buf, jboolean db, jint offset,
-        jint count, jlong jType, jint bType,
-        jint dest, jint sTag, jint source, jint rTag, jlongArray jStatus)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
-    MPI_Status status;
-
-    int rc = MPI_Sendrecv_replace(ptr, count, type, dest,
-                                  sTag, source, rTag, comm, &status);
-
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, jStatus, &status);
-
-    ompi_java_releaseWritePtr(ptr,item,env,buf,db,offset,count,type,bType);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_bSend(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject buf, jboolean db, jint offset,
-        jint count, jlong jType, jint bType, jint dest, jint tag)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
-
-    int rc = MPI_Bsend(ptr, count, type, dest, tag, comm);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_sSend(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject buf, jboolean db, jint offset,
-        jint count, jlong jType, jint bType, jint dest, jint tag)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
-
-    int rc = MPI_Ssend(ptr, count, type, dest, tag, comm);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_rSend(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject buf, jboolean db, jint offset,
-        jint count, jlong jType, jint bType, jint dest, jint tag)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
-
-    int rc = MPI_Rsend(ptr, count, type, dest, tag, comm);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iSend(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Isend(ptr, count, (MPI_Datatype)type,
-                       dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_ibSend(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Ibsend(ptr, count, (MPI_Datatype)type,
-                        dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_isSend(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Issend(ptr, count, (MPI_Datatype)type,
-                        dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_irSend(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Irsend(ptr, count, (MPI_Datatype)type,
-                        dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iRecv(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint source, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Irecv(ptr, count, (MPI_Datatype)type,
-                       source, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_sendInit(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Send_init(ptr, count, (MPI_Datatype)type,
-                           dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_bSendInit(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Bsend_init(ptr, count, (MPI_Datatype)type,
-                            dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_sSendInit(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Ssend_init(ptr, count, (MPI_Datatype)type,
-                            dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_rSendInit(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint dest, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Rsend_init(ptr, count, (MPI_Datatype)type,
-                            dest, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_recvInit(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint source, jint tag)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Recv_init(ptr, count, (MPI_Datatype)type,
-                           source, tag, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_pack(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject inBuf, jboolean indb, jint offset,
-        jint inCount, jlong jType, jbyteArray outBuf, jint position)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    int outSize = (*env)->GetArrayLength(env, outBuf);
-
-    void *oBufPtr, *iBufPtr, *iBufBase;
-    oBufPtr = (*env)->GetPrimitiveArrayCritical(env, outBuf, NULL);
-    iBufPtr = getBufCritical(&iBufBase, env, inBuf, indb, offset);
-
-    if(inCount != 0 && outSize != position)
-    {
-        /* LAM doesn't like count = 0 */
-        int rc = MPI_Pack(iBufPtr, inCount, type,
-                          oBufPtr, outSize, &position, comm);
-
-        ompi_java_exceptionCheck(env, rc);
-    }
-
-    releaseBufCritical(env, inBuf, indb, iBufBase);
-    (*env)->ReleasePrimitiveArrayCritical(env, outBuf, oBufPtr, 0);
-    return position;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_unpack(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jbyteArray inBuf, jint position, jobject outBuf, jboolean outdb,
-        jint offset, jint outCount, jlong jType)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    int inSize = (*env)->GetArrayLength(env, inBuf);
-
-    void *iBufPtr, *oBufPtr, *oBufBase;
-    iBufPtr = (*env)->GetPrimitiveArrayCritical(env, inBuf, NULL);
-    oBufPtr = getBufCritical(&oBufBase, env, outBuf, outdb, offset);
-
-    int rc = MPI_Unpack(iBufPtr, inSize, &position,
-                        oBufPtr, outCount, type, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleasePrimitiveArrayCritical(env, inBuf, iBufPtr, 0);
-    releaseBufCritical(env, outBuf, outdb, oBufBase);
-    return position;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_packSize(
-        JNIEnv *env, jobject jthis, jlong comm, jint incount, jlong type)
-{
-    int rc, size;
-    rc = MPI_Pack_size(incount, (MPI_Datatype)type, (MPI_Comm)comm, &size);
-    ompi_java_exceptionCheck(env, rc);
-    return size;
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Comm_iProbe(
-        JNIEnv *env, jobject jthis, jlong comm, jint source, jint tag)
-{
-    int flag;
-    MPI_Status status;
-    int rc = MPI_Iprobe(source, tag, (MPI_Comm)comm, &flag, &status);
-    ompi_java_exceptionCheck(env, rc);
-    return flag ? ompi_java_status_new(env, &status) : NULL;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_probe(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jint source, jint tag, jlongArray jStatus)
-{
-    MPI_Status status;
-    int rc = MPI_Probe(source, tag, (MPI_Comm)comm, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, jStatus, &status);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_getTopology(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    return getTopo(env, (MPI_Comm)comm);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_abort(
-        JNIEnv *env, jobject jthis, jlong comm, jint errorcode)
-{
-    int rc = MPI_Abort((MPI_Comm)comm, errorcode);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_setErrhandler(
-        JNIEnv *env, jobject jthis, jlong comm, jlong errhandler)
-{
-    int rc = MPI_Comm_set_errhandler((MPI_Comm)comm, (MPI_Errhandler)errhandler);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_getErrhandler(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    MPI_Errhandler errhandler;
-    int rc = MPI_Comm_get_errhandler((MPI_Comm)comm, &errhandler);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)errhandler;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_callErrhandler(
-        JNIEnv *env, jobject jthis, jlong comm, jint errorCode)
-{
-    int rc = MPI_Comm_call_errhandler((MPI_Comm)comm, errorCode);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-static int commCopyAttr(MPI_Comm oldcomm, int keyval, void *extraState,
-                        void *attrValIn, void *attrValOut, int *flag)
-{
-    return ompi_java_attrCopy(attrValIn, attrValOut, flag);
-}
-
-static int commDeleteAttr(MPI_Comm oldcomm, int keyval,
-                          void *attrVal, void *extraState)
-{
-    return ompi_java_attrDelete(attrVal);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Comm_createKeyval_1jni(
-                       JNIEnv *env, jclass clazz)
-{
-    int rc, keyval;
-    rc = MPI_Comm_create_keyval(commCopyAttr, commDeleteAttr, &keyval, NULL);
-    ompi_java_exceptionCheck(env, rc);
-    return keyval;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_freeKeyval_1jni(
-                       JNIEnv *env, jclass clazz, jint keyval)
-{
-    int rc = MPI_Comm_free_keyval((int*)(&keyval));
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_setAttr(
-        JNIEnv *env, jobject jthis, jlong comm, jint keyval, jbyteArray jval)
-{
-    void *cval = ompi_java_attrSet(env, jval);
-    int rc = MPI_Comm_set_attr((MPI_Comm)comm, keyval, cval);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Comm_getAttr_1predefined(
-        JNIEnv *env, jobject jthis, jlong comm, jint keyval)
-{
-    int flag, *val;
-    int rc = MPI_Comm_get_attr((MPI_Comm)comm, keyval, &val, &flag);
-
-    if(ompi_java_exceptionCheck(env, rc) || !flag)
-        return NULL;
-
-    return ompi_java_Integer_valueOf(env, (jint)(*val));
-}
-
-JNIEXPORT jbyteArray JNICALL Java_mpi_Comm_getAttr(
-        JNIEnv *env, jobject jthis, jlong comm, jint keyval)
-{
-    int flag;
-    void *cval;
-    int rc = MPI_Comm_get_attr((MPI_Comm)comm, keyval, &cval, &flag);
-
-    if(ompi_java_exceptionCheck(env, rc) || !flag)
-        return NULL;
-
-    return ompi_java_attrGet(env, cval);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_deleteAttr(
-        JNIEnv *env, jobject jthis, jlong comm, jint keyval)
-{
-    int rc = MPI_Comm_delete_attr((MPI_Comm)comm, keyval);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_barrier(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    int rc = MPI_Barrier((MPI_Comm)comm);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iBarrier(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    MPI_Request request;
-    int rc = MPI_Ibarrier((MPI_Comm)comm, &request);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_bcast(
-        JNIEnv *env, jobject jthis, jlong jComm, jobject buf, jboolean db,
-        jint offset, jint count, jlong jType, jint bType, jint root)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, offset, count, type, bType);
-
-    int rc = MPI_Bcast(ptr, count, type, root, comm);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseWritePtr(ptr,item,env,buf,db,offset,count,type,bType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iBcast(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject buf, jint count, jlong type, jint root)
-{
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_Ibcast(ptr, count, (MPI_Datatype)type,
-                        root, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_gather(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff, jint sCount,
-        jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff, jint rCount,
-        jlong rjType, jint rBType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank  = getRank(env, comm);
-    int inter = isInter(env, comm);
-    int rootOrInter = rank == root || inter;
-
-    void *sPtr, *rPtr = NULL;
-    ompi_java_buffer_t *sItem, *rItem;
-    MPI_Datatype sType;
-
-    if(sjType == 0)
-    {
-        assert(sBuf == NULL);
-        sType = MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        sType = (MPI_Datatype)sjType;
-
-        ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
-                             sOff, sCount, sType, sBType);
-    }
-
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-    int rCountTotal = rootOrInter ? rCount * getSize(env, comm, inter) : rCount;
-
-    if(rootOrInter || sPtr == MPI_IN_PLACE)
-    {
-        if(sPtr == MPI_IN_PLACE)
-        {
-            /* We use the receive buffer as the send buffer. */
-            ompi_java_getReadPtr(&rPtr, &rItem, env, rBuf, rdb,
-                                 rOff, rCountTotal, rType, rBType);
-        }
-        else
-        {
-            ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb,
-                                  rCountTotal, rType);
-        }
-
-        if(!rootOrInter)
-        {
-            /* The receive buffer is ignored for all non-root processes.
-             * As we are using MPI_IN_PLACE version, we use the receive
-             * buffer as the send buffer.
-             */
-            assert(sBuf == NULL);
-            sPtr   = rPtr;
-            sCount = rCount;
-            sType  = rType;
-        }
-    }
-
-    int rc = MPI_Gather(sPtr, sCount, sType, rPtr, rCount, rType, root, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(rootOrInter)
-    {
-        ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
-                                  rOff, rCountTotal, rType, rBType);
-    }
-    else if(sBuf == NULL)
-    {
-        ompi_java_releaseReadPtr(rPtr, rItem, rBuf, rdb);
-    }
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iGather(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jint sCount, jlong sType,
-        jobject recvBuf, jint rCount, jlong rType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank = getRank(env, comm);
-    int rootOrInter = rank == root || isInter(env, comm);
-
-    MPI_Request request;
-    void *sPtr, *rPtr = NULL;
-
-    if(sType == 0)
-    {
-        assert(sendBuf == NULL);
-        sType = (jlong)MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
-    }
-
-    if(rootOrInter || sPtr == MPI_IN_PLACE)
-    {
-        /*
-         * In principle need the "id == root" check here and elsewhere for
-         * correctness, in case arguments that are not supposed to be
-         * significant except on root are legitimately passed in as `null',
-         * say.  Shouldn't produce null pointer exception.
-         *
-         * (However in this case MPICH complains if `mpi_rtype' is not defined
-         * in all processes, notwithstanding what the spec says.)
-         */
-
-        rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-        if(!rootOrInter)
-        {
-            /* The receive buffer is ignored for all non-root processes.
-             * As we are using MPI_IN_PLACE version, we use the receive
-             * buffer as the send buffer.
-             */
-            assert(sendBuf == NULL);
-            sPtr   = rPtr;
-            sCount = rCount;
-            sType  = rType;
-        }
-    }
-
-    int rc = MPI_Igather(sPtr, sCount, (MPI_Datatype)sType,
-                         rPtr, rCount, (MPI_Datatype)rType,
-                         root, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_gatherv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jint sCount, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff, jintArray rCounts,
-        jintArray displs, jlong rjType, jint rBType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank  = getRank(env, comm);
-    int inter = isInter(env, comm);
-    int rootOrInter = rank == root || inter;
-    int size = rootOrInter ? getSize(env, comm, inter) : 0;
-
-    void *sPtr, *rPtr = NULL;
-    ompi_java_buffer_t *sItem, *rItem;
-    MPI_Datatype sType;
-
-    if(sjType == 0)
-    {
-        assert(sBuf == NULL);
-        sType = MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        sType = (MPI_Datatype)sjType;
-
-        ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
-                             sOff, sCount, sType, sBType);
-    }
-
-    jint *jRCounts = NULL, *jDispls = NULL;
-    int  *cRCounts = NULL, *cDispls = NULL;
-    MPI_Datatype rType = sType;
-
-    if(rootOrInter)
-    {
-        ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
-        ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-        rType = (MPI_Datatype)rjType;
-
-        if(sPtr == MPI_IN_PLACE)
-        {
-            /* We use the receive buffer as the send buffer. */
-            ompi_java_getReadPtrv(&rPtr, &rItem, env, rBuf, rdb, rOff,
-                                  cRCounts, cDispls, size, root, rType, rBType);
-        }
-        else
-        {
-            ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
-                                   cRCounts, cDispls, size, rType);
-        }
-    }
-
-    int rc = MPI_Gatherv(sPtr, sCount, sType, rPtr, cRCounts,
-                         cDispls, rType, root, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    if(rootOrInter)
-    {
-        ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
-                                   cRCounts, cDispls, size, rType, rBType);
-
-        ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
-        ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-    }
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iGatherv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jint sCount, jlong sType,
-        jobject recvBuf, jintArray rCounts,
-        jintArray displs, jlong rType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank = getRank(env, comm);
-    int rootOrInter = rank == root || isInter(env, comm);
-
-    MPI_Request request;
-    void *sPtr, *rPtr = NULL;
-
-    if(sType == 0)
-    {
-        assert(sendBuf == NULL);
-        sType = (jlong)MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
-    }
-
-    jint *jRCounts, *jDispls;
-    int  *cRCounts, *cDispls;
-
-    if(rootOrInter)
-    {
-        ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
-        ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-        rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-    }
-    else
-    {
-        jRCounts = jDispls = NULL;
-        cRCounts = cDispls = NULL;
-        rType = sType;
-    }
-
-    int rc = MPI_Igatherv(sPtr, sCount, (MPI_Datatype)sType, rPtr,
-                          cRCounts, cDispls, (MPI_Datatype)rType,
-                          root, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(rootOrInter)
-    {
-        ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
-        ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-    }
-
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_scatter(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff, jint sCount,
-        jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff, jint rCount,
-        jlong rjType, jint rBType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank  = getRank(env, comm);
-    int inter = isInter(env, comm);
-    int rootOrInter = rank == root || inter;
-
-    void *sPtr = NULL, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem = NULL;
-    MPI_Datatype rType;
-
-    if(rjType == 0)
-    {
-        assert(rBuf == NULL);
-        rType = MPI_DATATYPE_NULL;
-        rPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        rType = (MPI_Datatype)rjType;
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rCount, rType);
-    }
-
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    int sCountTotal = rootOrInter ? sCount * getSize(env, comm, inter) : sCount;
-
-    if(rootOrInter || rPtr == MPI_IN_PLACE)
-    {
-        ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb, sOff,
-                             sCountTotal, sType, sBType);
-        if(!rootOrInter)
-        {
-            /* The send buffer is ignored for all non-root processes.
-             * As we are using MPI_IN_PLACE version, we use the send
-             * buffer as the receive buffer.
-             */
-            assert(rBuf == NULL);
-            rPtr   = sPtr;
-            rCount = sCount;
-            rType  = sType;
-        }
-    }
-
-    int rc = MPI_Scatter(sPtr, sCount, sType, rPtr, rCount, rType, root, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(rootOrInter)
-    {
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-    }
-    else if(rBuf == NULL)
-    {
-        ompi_java_releaseWritePtr(sPtr, sItem, env, sBuf, sdb,
-                                  sOff, sCount, sType, sBType);
-    }
-
-    if(rItem != NULL && rBuf != NULL)
-    {
-        ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
-                                  rOff, rCount, rType, rBType);
-    }
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatter(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jint sCount, jlong sType,
-        jobject recvBuf, jint rCount, jlong rType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank = getRank(env, comm);
-    int rootOrInter = rank == root || isInter(env, comm);
-
-    void *sPtr = NULL, *rPtr;
-    MPI_Request request;
-
-    if(rType == 0)
-    {
-        assert(recvBuf == NULL);
-        rType = (jlong)MPI_DATATYPE_NULL;
-        rPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-    }
-
-    if(rootOrInter || rPtr == MPI_IN_PLACE)
-    {
-        sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
-
-        if(!rootOrInter)
-        {
-            /* The send buffer is ignored for all non-root processes.
-             * As we are using MPI_IN_PLACE version, we use the send
-             * buffer as the receive buffer.
-             */
-            assert(recvBuf == NULL);
-            rPtr   = sPtr;
-            rCount = sCount;
-            rType  = sType;
-        }
-    }
-
-    int rc = MPI_Iscatter(sPtr, sCount, (MPI_Datatype)sType,
-                          rPtr, rCount, (MPI_Datatype)rType,
-                          root, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_scatterv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff, jintArray sCounts,
-        jintArray displs, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff, jint rCount,
-        jlong rjType, jint rBType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank  = getRank(env, comm);
-    int inter = isInter(env, comm);
-    int rootOrInter = rank == root || inter;
-    int size = rootOrInter ? getSize(env, comm, inter) : 0;
-
-    void *sPtr = NULL, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem = NULL;
-    MPI_Datatype rType;
-
-    if(rjType == 0)
-    {
-        assert(rBuf == NULL);
-        rType = MPI_DATATYPE_NULL;
-        rPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        rType = (MPI_Datatype)rjType;
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rCount, rType);
-    }
-
-    jint *jSCounts = NULL, *jDispls = NULL;
-    int  *cSCounts = NULL, *cDispls = NULL;
-    MPI_Datatype sType = rType;
-
-    if(rootOrInter)
-    {
-        ompi_java_getIntArray(env, sCounts, &jSCounts, &cSCounts);
-        ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-        sType = (MPI_Datatype)sjType;
-
-        ompi_java_getReadPtrv(&sPtr, &sItem, env, sBuf, sdb, sOff,
-                              cSCounts, cDispls, size, -1, sType, sBType);
-    }
-
-    int rc = MPI_Scatterv(sPtr, cSCounts, cDispls, sType,
-                          rPtr, rCount, rType, root, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(rItem != NULL && rBuf != NULL)
-    {
-        ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
-                                  rOff, rCount, rType, rBType);
-    }
-
-    if(rootOrInter)
-    {
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-        ompi_java_forgetIntArray(env, sCounts, jSCounts, cSCounts);
-        ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-    }
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iScatterv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jintArray sCounts, jintArray displs, jlong sType,
-        jobject recvBuf, jint rCount, jlong rType, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank = getRank(env, comm);
-    int rootOrInter = rank == root || isInter(env, comm);
-
-    MPI_Request request;
-    void *sPtr = NULL, *rPtr;
-
-    if(rType == 0)
-    {
-        assert(recvBuf == NULL);
-        rType = (jlong)MPI_DATATYPE_NULL;
-        rPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-    }
-
-    jint *jSCounts, *jDispls;
-    int  *cSCounts, *cDispls;
-
-    if(rootOrInter)
-    {
-        ompi_java_getIntArray(env, sCounts, &jSCounts, &cSCounts);
-        ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-        sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
-    }
-    else
-    {
-        jSCounts = jDispls = NULL;
-        cSCounts = cDispls = NULL;
-        sType = rType;
-    }
-
-    int rc = MPI_Iscatterv(sPtr, cSCounts, cDispls, (MPI_Datatype)sType,
-                           rPtr, rCount, (MPI_Datatype)rType, root,
-                           comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(rootOrInter)
-    {
-        ompi_java_forgetIntArray(env, sCounts, jSCounts, cSCounts);
-        ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-    }
-
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_allGather(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jint sCount, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jint rCount, jlong rjType, jint rBType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType,
-                 rType = (MPI_Datatype)rjType;
-
-    int inter  = isInter(env, comm),
-        size   = getSize(env, comm, inter),
-        rTotal = rCount * size;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    if(sjType == 0)
-    {
-        assert(sBuf == NULL);
-        sType = MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-        int rank = getRank(env, comm);
-
-        ompi_java_getReadPtrRank(&rPtr, &rItem, env, rBuf, rdb, rOff,
-                                 rCount, size, rank, rType, rBType);
-    }
-    else
-    {
-        sType = (MPI_Datatype)sjType;
-
-        ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
-                             sOff, sCount, sType, sBType);
-
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
-    }
-
-    int rc = MPI_Allgather(sPtr, sCount, sType, rPtr, rCount, rType, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseWritePtr(rPtr, rItem, env, rBuf, rdb,
-                              rOff, rTotal, rType, rBType);
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGather(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jint sCount, jlong sType,
-        jobject recvBuf, jint rCount, jlong rType)
-{
-    void *sPtr, *rPtr;
-    MPI_Request request;
-
-    if(sType == 0)
-    {
-        assert(sendBuf == NULL);
-        sType = (jlong)MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
-    }
-
-    rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    int rc = MPI_Iallgather(sPtr, sCount, (MPI_Datatype)sType,
-                            rPtr, rCount, (MPI_Datatype)rType,
-                            (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_allGatherv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jint sCount, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jintArray rCounts, jintArray displs, jlong rjType, jint rBType)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int inter = isInter(env, comm),
-        size  = getSize(env, comm, inter);
-
-    MPI_Datatype sType,
-                 rType = (MPI_Datatype)rjType;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-    jint *jRCounts, *jDispls;
-    int  *cRCounts, *cDispls;
-    ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
-    ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-
-    if(sjType == 0)
-    {
-        assert(sBuf == NULL);
-        sType = MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-        int rank = getRank(env, comm);
-
-        ompi_java_getReadPtrv(&rPtr, &rItem, env, rBuf, rdb, rOff,
-                              cRCounts, cDispls, size, rank, rType, rBType);
-    }
-    else
-    {
-        sType = (MPI_Datatype)sjType;
-
-        ompi_java_getReadPtr(&sPtr, &sItem, env, sBuf, sdb,
-                             sOff, sCount, sType, sBType);
-
-        ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
-                               cRCounts, cDispls, size, rType);
-    }
-
-    int rc = MPI_Allgatherv(sPtr, sCount, sType, rPtr,
-                            cRCounts, cDispls, rType, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
-                               cRCounts, cDispls, size, rType, rBType);
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
-    ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllGatherv(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jint sCount, jlong sType,
-        jobject recvBuf, jintArray rCounts, jintArray displs, jlong rType)
-{
-    MPI_Request request;
-    void *sPtr, *rPtr;
-
-    if(sType == 0)
-    {
-        assert(sendBuf == NULL);
-        sType = (jlong)MPI_DATATYPE_NULL;
-        sPtr  = MPI_IN_PLACE;
-    }
-    else
-    {
-        sPtr = ompi_java_getDirectBufferAddress(env, sendBuf);
-    }
-
-    jint *jRCounts, *jDispls;
-    int  *cRCounts, *cDispls;
-    ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
-    ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-
-    rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    int rc = MPI_Iallgatherv(sPtr, sCount, (MPI_Datatype)sType,
-                             rPtr, cRCounts, cDispls, (MPI_Datatype)rType,
-                             (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
-    ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_allToAll(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jint sCount, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jint rCount, jlong rjType, jint rBType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    int inter  = isInter(env, comm),
-        size   = getSize(env, comm, inter),
-        sTotal = sCount * size,
-        rTotal = rCount * size;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-    ompi_java_getReadPtr(&sPtr, &sItem, env,sBuf,sdb,sOff,sTotal,sType,sBType);
-    ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
-
-    int rc = MPI_Alltoall(sPtr, sCount, sType, rPtr, rCount, rType, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rTotal,rType,rBType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAll(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jint sCount, jlong sType,
-        jobject recvBuf, jint rCount, jlong rType)
-{
-    void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
-         *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    MPI_Request request;
-
-    int rc = MPI_Ialltoall(sPtr, sCount, (MPI_Datatype)sType,
-                           rPtr, rCount, (MPI_Datatype)rType,
-                           (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_allToAllv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff, jintArray sCount,
-        jintArray sDispl, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff, jintArray rCount,
-        jintArray rDispl, jlong rjType, jint rBType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    int inter = isInter(env, comm),
-        size  = getSize(env, comm, inter);
-
-    jint *jSCount, *jRCount, *jSDispl, *jRDispl;
-    int  *cSCount, *cRCount, *cSDispl, *cRDispl;
-    ompi_java_getIntArray(env, sCount, &jSCount, &cSCount);
-    ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
-    ompi_java_getIntArray(env, sDispl, &jSDispl, &cSDispl);
-    ompi_java_getIntArray(env, rDispl, &jRDispl, &cRDispl);
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    ompi_java_getReadPtrv(&sPtr, &sItem, env, sBuf, sdb, sOff,
-                          cSCount, cSDispl, size, -1, sType, sBType);
-    ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
-                           cRCount, cRDispl, size, rType);
-
-    int rc = MPI_Alltoallv(sPtr, cSCount, cSDispl, sType,
-                           rPtr, cRCount, cRDispl, rType, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
-                               cRCount, cRDispl, size, rType, rBType);
-
-    ompi_java_forgetIntArray(env, sCount, jSCount, cSCount);
-    ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
-    ompi_java_forgetIntArray(env, sDispl, jSDispl, cSDispl);
-    ompi_java_forgetIntArray(env, rDispl, jRDispl, cRDispl);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAllv(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jintArray sCount, jintArray sDispls, jlong sType,
-        jobject recvBuf, jintArray rCount, jintArray rDispls, jlong rType)
-{
-    jint *jSCount, *jRCount, *jSDispls, *jRDispls;
-    int  *cSCount, *cRCount, *cSDispls, *cRDispls;
-    ompi_java_getIntArray(env, sCount, &jSCount, &cSCount);
-    ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
-    ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
-    ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
-
-    void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
-         *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    MPI_Request request;
-
-    int rc = MPI_Ialltoallv(sPtr, cSCount, cSDispls, (MPI_Datatype)sType,
-                            rPtr, cRCount, cRDispls, (MPI_Datatype)rType,
-                            (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
-    ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
-    ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
-    ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_allToAllw(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jintArray sOffs, jintArray sCount,
-        jintArray sDispls, jlongArray sTypes, jintArray sBtypes,
-        jobject rBuf, jboolean rdb, jintArray rOffs, jintArray rCount,
-        jintArray rDispls, jlongArray rTypes, jintArray rBtypes)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-
-    int inter = isInter(env, comm),
-        size  = getSize(env, comm, inter);
-
-    jlong* jSTypes, *jRTypes;
-    MPI_Datatype *cSTypes, *cRTypes;
-
-    ompi_java_getDatatypeArray(env, sTypes, &jSTypes, &cSTypes);
-    ompi_java_getDatatypeArray(env, rTypes, &jRTypes, &cRTypes);
-
-    jint *jSCount, *jRCount, *jSDispls, *jRDispls;
-    int  *cSCount, *cRCount, *cSDispls, *cRDispls;
-    jint *jSBtypes, *jRBtypes;
-    int  *cSBtypes, *cRBtypes;
-    jint *jSOffs, *jROffs;
-    int  *cSOffs, *cROffs;
-
-    ompi_java_getIntArray(env, sCount,  &jSCount,  &cSCount);
-    ompi_java_getIntArray(env, rCount,  &jRCount,  &cRCount);
-    ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
-    ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
-    ompi_java_getIntArray(env, sBtypes, &jSBtypes, &cSBtypes);
-    ompi_java_getIntArray(env, rBtypes, &jRBtypes, &cRBtypes);
-    ompi_java_getIntArray(env, sOffs, &jSOffs, &cSOffs);
-    ompi_java_getIntArray(env, rOffs, &jROffs, &cROffs);
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    ompi_java_getReadPtrw(&sPtr, &sItem, env, sBuf, sdb, cSOffs,
-                          cSCount, cSDispls, size, -1, cSTypes, cSBtypes);
-    ompi_java_getWritePtrw(&rPtr, &rItem, env, rBuf, rdb,
-                           cRCount, cRDispls, size, cRTypes);
-
-    int rc = MPI_Alltoallw(sPtr, cSCount, cSDispls, cSTypes,
-                           rPtr, cRCount, cRDispls, cRTypes, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtrw(rPtr, rItem, env, rBuf, rdb, cROffs,
-                               cRCount, cRDispls, size, cRTypes, cRBtypes);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
-    ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
-    ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
-    ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
-    ompi_java_forgetIntArray(env, sBtypes, jSBtypes, cSBtypes);
-    ompi_java_forgetIntArray(env, rBtypes, jRBtypes, cRBtypes);
-    ompi_java_forgetIntArray(env, sOffs, jSOffs, cSOffs);
-    ompi_java_forgetIntArray(env, rOffs, jROffs, cROffs);
-    ompi_java_forgetDatatypeArray(env, sTypes, jSTypes, cSTypes);
-    ompi_java_forgetDatatypeArray(env, rTypes, jRTypes, cRTypes);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllToAllw(
-		JNIEnv *env, jobject jthis, jlong jComm,
-				jobject sendBuf, jintArray sCount, jintArray sDispls, jlongArray sTypes,
-				jobject recvBuf, jintArray rCount, jintArray rDispls, jlongArray rTypes)
-{
-	MPI_Comm     comm  = (MPI_Comm)jComm;
-
-	jlong* jSTypes, *jRTypes;
-	MPI_Datatype *cSTypes, *cRTypes;
-
-	ompi_java_getDatatypeArray(env, sTypes, &jSTypes, &cSTypes);
-	ompi_java_getDatatypeArray(env, rTypes, &jRTypes, &cRTypes);
-
-	jint *jSCount, *jRCount, *jSDispls, *jRDispls;
-	int  *cSCount, *cRCount, *cSDispls, *cRDispls;
-	ompi_java_getIntArray(env, sCount,  &jSCount,  &cSCount);
-	ompi_java_getIntArray(env, rCount,  &jRCount,  &cRCount);
-	ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
-	ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
-
-	void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
-	     *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-	MPI_Request request;
-
-	int rc = MPI_Ialltoallw(
-			sPtr, cSCount, cSDispls, cSTypes,
-			rPtr, cRCount, cRDispls, cRTypes, comm, &request);
-
-	ompi_java_exceptionCheck(env, rc);
-	ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
-	ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
-	ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
-	ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
-	ompi_java_forgetDatatypeArray(env, sTypes, jSTypes, cSTypes);
-	ompi_java_forgetDatatypeArray(env, rTypes, jRTypes, cRTypes);
-
-	return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllGather(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jint sCount, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jint rCount, jlong rjType, jint rBType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    int sSize, rSize;
-    getNeighbors(env, comm, &sSize, &rSize);
-    int rTotal = rCount * rSize;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-    ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,sCount,sType,sBType);
-    ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
-
-    int rc = MPI_Neighbor_allgather(
-             sPtr, sCount, sType, rPtr, rCount, rType, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rTotal,rType,rBType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllGather(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jint sCount, jlong sjType,
-        jobject recvBuf, jint rCount, jlong rjType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
-         *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    MPI_Request request;
-
-    int rc = MPI_Ineighbor_allgather(
-             sPtr, sCount, sType, rPtr, rCount, rType, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllGatherv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jint sCount, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jintArray rCount, jintArray displs, jlong rjType, jint rBType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    int sSize, rSize;
-    getNeighbors(env, comm, &sSize, &rSize);
-
-    jint *jRCount, *jDispls;
-    int  *cRCount, *cDispls;
-    ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
-    ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-    ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,sCount,sType,sBType);
-
-    ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
-                           cRCount, cDispls, rSize, rType);
-
-    int rc = MPI_Neighbor_allgatherv(
-             sPtr, sCount, sType, rPtr, cRCount, cDispls, rType, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
-                               cRCount, cDispls, rSize, rType, rBType);
-
-    ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
-    ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllGatherv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jint sCount, jlong sjType,
-        jobject recvBuf, jintArray rCount, jintArray displs, jlong rjType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    jint *jRCount, *jDispls;
-    int  *cRCount, *cDispls;
-    ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
-    ompi_java_getIntArray(env, displs, &jDispls, &cDispls);
-
-    void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
-         *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    MPI_Request request;
-
-    int rc = MPI_Ineighbor_allgatherv(sPtr, sCount, sType, rPtr, cRCount,
-                                      cDispls, rType, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
-    ompi_java_forgetIntArray(env, displs, jDispls, cDispls);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllToAll(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jint sCount, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jint rCount, jlong rjType, jint rBType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    int sSize, rSize;
-    getNeighbors(env, comm, &sSize, &rSize);
-    int sTotal = sCount * sSize;
-    int rTotal = rCount * rSize;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-    ompi_java_getReadPtr(&sPtr, &sItem, env,sBuf,sdb,sOff,sTotal,sType,sBType);
-    ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rTotal, rType);
-
-    int rc = MPI_Neighbor_alltoall(
-             sPtr, sCount, sType, rPtr, rCount, rType, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rTotal,rType,rBType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllToAll(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jint sCount, jlong sjType,
-        jobject recvBuf, jint rCount, jlong rjType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
-         *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    MPI_Request request;
-
-    int rc = MPI_Ineighbor_alltoall(
-             sPtr, sCount, sType, rPtr, rCount, rType, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_neighborAllToAllv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jintArray sCount, jintArray sDispl, jlong sjType, jint sBType,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jintArray rCount, jintArray rDispl, jlong rjType, jint rBType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    int sSize, rSize;
-    getNeighbors(env, comm, &sSize, &rSize);
-
-    jint *jSCount, *jRCount, *jSDispl, *jRDispl;
-    int  *cSCount, *cRCount, *cSDispl, *cRDispl;
-    ompi_java_getIntArray(env, sCount, &jSCount, &cSCount);
-    ompi_java_getIntArray(env, rCount, &jRCount, &cRCount);
-    ompi_java_getIntArray(env, sDispl, &jSDispl, &cSDispl);
-    ompi_java_getIntArray(env, rDispl, &jRDispl, &cRDispl);
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    ompi_java_getReadPtrv(&sPtr, &sItem, env, sBuf, sdb, sOff,
-                          cSCount, cSDispl, sSize, -1, sType, sBType);
-    ompi_java_getWritePtrv(&rPtr, &rItem, env, rBuf, rdb,
-                           cRCount, cRDispl, rSize, rType);
-
-    int rc = MPI_Neighbor_alltoallv(sPtr, cSCount, cSDispl, sType,
-                                    rPtr, cRCount, cRDispl, rType, comm);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtrv(rPtr, rItem, env, rBuf, rdb, rOff,
-                               cRCount, cRDispl, rSize, rType, rBType);
-
-    ompi_java_forgetIntArray(env, sCount, jSCount, cSCount);
-    ompi_java_forgetIntArray(env, rCount, jRCount, cRCount);
-    ompi_java_forgetIntArray(env, sDispl, jSDispl, cSDispl);
-    ompi_java_forgetIntArray(env, rDispl, jRDispl, cRDispl);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iNeighborAllToAllv(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jintArray sCount, jintArray sDispls, jlong sjType,
-        jobject recvBuf, jintArray rCount, jintArray rDispls, jlong rjType)
-{
-    MPI_Comm     comm  = (MPI_Comm)jComm;
-    MPI_Datatype sType = (MPI_Datatype)sjType;
-    MPI_Datatype rType = (MPI_Datatype)rjType;
-
-    jint *jSCount, *jRCount, *jSDispls, *jRDispls;
-    int  *cSCount, *cRCount, *cSDispls, *cRDispls;
-    ompi_java_getIntArray(env, sCount,  &jSCount,  &cSCount);
-    ompi_java_getIntArray(env, rCount,  &jRCount,  &cRCount);
-    ompi_java_getIntArray(env, sDispls, &jSDispls, &cSDispls);
-    ompi_java_getIntArray(env, rDispls, &jRDispls, &cRDispls);
-
-    void *sPtr = ompi_java_getDirectBufferAddress(env, sendBuf),
-         *rPtr = ompi_java_getDirectBufferAddress(env, recvBuf);
-
-    MPI_Request request;
-
-    int rc = MPI_Ineighbor_alltoallv(
-             sPtr, cSCount, cSDispls, sType,
-             rPtr, cRCount, cRDispls, rType, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, sCount,  jSCount,  cSCount);
-    ompi_java_forgetIntArray(env, rCount,  jRCount,  cRCount);
-    ompi_java_forgetIntArray(env, sDispls, jSDispls, cSDispls);
-    ompi_java_forgetIntArray(env, rDispls, jRDispls, cRDispls);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_reduce(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jobject rBuf, jboolean rdb, jint rOff, jint count,
-        jlong jType, jint bType, jobject jOp, jlong hOp, jint root)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    int rank = getRank(env, comm);
-    int rootOrInter = rank == root || isInter(env, comm);
-
-    void *sPtr, *rPtr = NULL;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    if(sBuf == NULL)
-    {
-        ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
-        sPtr = rootOrInter ? MPI_IN_PLACE : rPtr;
-        /* The receive buffer is ignored for all non-root processes.
-         * On MPI_IN_PLACE version we use receive buffer as the send buffer.
-         */
-    }
-    else
-    {
-        ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
-
-        if(rootOrInter)
-            ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
-    }
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    int rc = MPI_Reduce(sPtr, rPtr, count, type, op, root, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    if(rootOrInter)
-        ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
-    else if(sBuf == NULL)
-        ompi_java_releaseReadPtr(rPtr, rItem, rBuf, rdb);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduce(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sendBuf, jobject recvBuf, int count,
-        jlong type, jint baseType, jobject jOp, jlong hOp, jint root)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    int rank = getRank(env, comm);
-    int rootOrInter = rank == root || isInter(env, comm);
-
-    void *sPtr, *rPtr = NULL;
-    MPI_Request request;
-
-    if(sendBuf == NULL)
-        sPtr = MPI_IN_PLACE;
-    else
-        sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
-
-    if(rootOrInter || sendBuf == NULL)
-    {
-        rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
-
-        if(!rootOrInter)
-        {
-            /* The receive buffer is ignored for all non-root processes.
-             * As we are using MPI_IN_PLACE version, we use the receive
-             * buffer as the send buffer.
-             */
-            assert(sendBuf == NULL);
-            sPtr = rPtr;
-        }
-    }
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
-
-    int rc = MPI_Ireduce(sPtr, rPtr, count, (MPI_Datatype)type,
-                         op, root, comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_allReduce(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jint count, jlong jType, jint bType, jobject jOp, jlong hOp)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    if(sBuf == NULL)
-    {
-        sPtr = MPI_IN_PLACE;
-        ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
-    }
-    else
-    {
-        ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
-    }
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    int rc = MPI_Allreduce(sPtr, rPtr, count, type, op, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iAllReduce(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jobject recvBuf, jint count,
-        jlong type, jint baseType, jobject jOp, jlong hOp)
-{
-    MPI_Request request;
-    void *sPtr, *rPtr;
-
-    if(sendBuf == NULL)
-        sPtr = MPI_IN_PLACE;
-    else
-        sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
-
-    rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
-
-    int rc = MPI_Iallreduce(sPtr, rPtr, count, (MPI_Datatype)type,
-                            op, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatter(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jintArray rCounts, jlong jType, jint bType, jobject jOp, jlong hOp)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    jint *jRCounts;
-    int  *cRCounts;
-    ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
-
-    int size  = getGroupSize(env, comm),
-        count = getSum(cRCounts, size),
-        rbCnt; /* Receive buffer count */
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    if(sBuf == NULL)
-    {
-        sPtr  = MPI_IN_PLACE;
-        rbCnt = count;
-        ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
-    }
-    else
-    {
-        ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
-        rbCnt = cRCounts[getRank(env, comm)];
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rbCnt, type);
-    }
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    int rc = MPI_Reduce_scatter(sPtr, rPtr, cRCounts, type, op, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rbCnt,type,bType);
-    ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatter(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jobject recvBuf, jintArray rCounts,
-        jlong type, int bType, jobject jOp, jlong hOp)
-{
-    void *sPtr, *rPtr;
-
-    if(sendBuf == NULL)
-        sPtr = MPI_IN_PLACE;
-    else
-        sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
-
-    rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    MPI_Request request;
-
-    jint *jRCounts;
-    int  *cRCounts;
-    ompi_java_getIntArray(env, rCounts, &jRCounts, &cRCounts);
-
-    int rc = MPI_Ireduce_scatter(sPtr, rPtr, cRCounts, (MPI_Datatype)type,
-                                 op, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, rCounts, jRCounts, cRCounts);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_reduceScatterBlock(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jobject rBuf, jboolean rdb, jint rOff,
-        jint rCount, jlong jType, jint bType, jobject jOp, jlong hOp)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    int count = rCount * getGroupSize(env, comm),
-        rbCnt; /* Receive buffer count */
-
-    if(sBuf == NULL)
-    {
-        sPtr  = MPI_IN_PLACE;
-        rbCnt = count;
-        ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
-    }
-    else
-    {
-        ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
-        rbCnt = rCount;
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, rbCnt, type);
-    }
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    int rc = MPI_Reduce_scatter_block(sPtr, rPtr, rCount, type, op, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,rbCnt,type,bType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Comm_iReduceScatterBlock(
-        JNIEnv *env, jobject jthis, jlong comm, jobject sendBuf,
-        jobject recvBuf, jint count, jlong type, jint bType,
-        jobject jOp, jlong hOp)
-{
-    void *sPtr, *rPtr;
-
-    if(sendBuf == NULL)
-        sPtr = MPI_IN_PLACE;
-    else
-        sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
-
-    rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    MPI_Request request;
-
-    int rc = MPI_Ireduce_scatter_block(sPtr, rPtr, count, (MPI_Datatype)type,
-                                       op, (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_reduceLocal(
-        JNIEnv *env, jclass clazz, jobject inBuf, jboolean idb, jint inOff,
-        jobject inOutBuf, jboolean iodb, jint inOutOff, jint count,
-        jlong jType, jlong op)
-{
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *inPtr, *inBase, *inOutPtr, *inOutBase;
-    inPtr = getBufCritical(&inBase, env, inBuf, idb, inOff);
-    inOutPtr = getBufCritical(&inOutBase, env, inOutBuf, iodb, inOutOff);
-    int rc = MPI_Reduce_local(inPtr, inOutPtr, count, type, (MPI_Op)op);
-    ompi_java_exceptionCheck(env, rc);
-    releaseBufCritical(env, inBuf, idb, inBase);
-    releaseBufCritical(env, inOutBuf, iodb, inOutBase);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_reduceLocalUf(
-        JNIEnv *env, jclass clazz, jobject inBuf, jboolean idb, jint inOff,
-        jobject inOutBuf, jboolean iodb, jint inOutOff, jint count,
-        jlong jType, jint bType, jobject jOp, jlong hOp)
-{
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *inPtr, *inOutPtr;
-    ompi_java_buffer_t *inItem, *inOutItem;
-
-    ompi_java_getReadPtr(&inPtr, &inItem, env, inBuf,
-                         idb, inOff, count, type, bType);
-    ompi_java_getReadPtr(&inOutPtr, &inOutItem, env, inOutBuf,
-                         iodb, inOutOff, count, type, bType);
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    int rc = MPI_Reduce_local(inPtr, inOutPtr, count, type, op);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(inPtr, inItem, inBuf, idb);
-
-    ompi_java_releaseWritePtr(inOutPtr, inOutItem, env, inOutBuf,
-                              iodb, inOutOff, count, type, bType);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Comm_setName(
-        JNIEnv *env, jobject jthis, jlong handle, jstring jname)
-{
-    const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
-    int rc = MPI_Comm_set_name((MPI_Comm)handle, (char*)name);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jname, name);
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_Comm_getName(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    char name[MPI_MAX_OBJECT_NAME];
-    int len;
-    int rc = MPI_Comm_get_name((MPI_Comm)handle, name, &len);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    return (*env)->NewStringUTF(env, name);
-}
diff --git a/ompi/mpi/java/c/mpi_Constant.c b/ompi/mpi/java/c/mpi_Constant.c
deleted file mode 100644
index 06884743e62..00000000000
--- a/ompi/mpi/java/c/mpi_Constant.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2020 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#include "ompi_config.h"
-
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi_Constant.h"
-#include "mpiJava.h"
-
-void ompi_java_setStaticLongField(JNIEnv *env, jclass c,
-                                  char *field, jlong value)
-{
-    jfieldID id = (*env)->GetStaticFieldID(env, c, field, "J");
-    (*env)->SetStaticLongField(env, c, id, value);
-}
-
-void ompi_java_setIntField(JNIEnv *env, jclass c, jobject obj,
-                           char *field, jint value)
-{
-    jfieldID id = (*env)->GetFieldID(env, c, field, "I");
-    (*env)->SetIntField(env, obj, id, value);
-}
-
-/*
- * Class:     mpi_Constant
- * Method:    setConstant
- * Signature: ()V
- */
-JNIEXPORT void JNICALL Java_mpi_Constant_setConstant(JNIEnv *env, jobject obj)
-{
-    jclass c = (*env)->GetObjectClass(env, obj);
-    ompi_java_setIntField(env, c, obj, "THREAD_SINGLE",     MPI_THREAD_SINGLE);
-    ompi_java_setIntField(env, c, obj, "THREAD_FUNNELED",   MPI_THREAD_FUNNELED);
-    ompi_java_setIntField(env, c, obj, "THREAD_SERIALIZED", MPI_THREAD_SERIALIZED);
-    ompi_java_setIntField(env, c, obj, "THREAD_MULTIPLE",   MPI_THREAD_MULTIPLE);
-
-    ompi_java_setIntField(env, c, obj, "ANY_SOURCE", MPI_ANY_SOURCE);
-    ompi_java_setIntField(env, c, obj, "ANY_TAG",    MPI_ANY_TAG);
-    ompi_java_setIntField(env, c, obj, "PROC_NULL",  MPI_PROC_NULL);
-    ompi_java_setIntField(env, c, obj, "GRAPH",      MPI_GRAPH);
-    ompi_java_setIntField(env, c, obj, "DIST_GRAPH", MPI_DIST_GRAPH);
-    ompi_java_setIntField(env, c, obj, "CART",       MPI_CART);
-
-    ompi_java_setIntField(env, c, obj, "UNDEFINED",  MPI_UNDEFINED);
-    ompi_java_setIntField(env, c, obj, "IDENT",      MPI_IDENT);
-    ompi_java_setIntField(env, c, obj, "CONGRUENT",  MPI_CONGRUENT);
-    ompi_java_setIntField(env, c, obj, "SIMILAR",    MPI_SIMILAR);
-    ompi_java_setIntField(env, c, obj, "UNEQUAL",    MPI_UNEQUAL);
-
-    ompi_java_setIntField(env, c, obj, "TAG_UB",          MPI_TAG_UB);
-    ompi_java_setIntField(env, c, obj, "HOST",            MPI_HOST);
-    ompi_java_setIntField(env, c, obj, "IO",              MPI_IO);
-    ompi_java_setIntField(env, c, obj, "WTIME_IS_GLOBAL", MPI_WTIME_IS_GLOBAL);
-    ompi_java_setIntField(env, c, obj, "APPNUM",          MPI_APPNUM);
-    ompi_java_setIntField(env, c, obj, "LASTUSEDCODE",    MPI_LASTUSEDCODE);
-    ompi_java_setIntField(env, c, obj, "UNIVERSE_SIZE",   MPI_UNIVERSE_SIZE);
-    ompi_java_setIntField(env, c, obj, "WIN_BASE",        MPI_WIN_BASE);
-    ompi_java_setIntField(env, c, obj, "WIN_SIZE",        MPI_WIN_SIZE);
-    ompi_java_setIntField(env, c, obj, "WIN_DISP_UNIT",   MPI_WIN_DISP_UNIT);
-
-    ompi_java_setIntField(env, c, obj, "VERSION", MPI_VERSION);
-    ompi_java_setIntField(env, c, obj, "SUBVERSION", MPI_SUBVERSION);
-    ompi_java_setIntField(env, c, obj, "ROOT", MPI_ROOT);
-    ompi_java_setIntField(env, c, obj, "KEYVAL_INVALID", MPI_KEYVAL_INVALID);
-    ompi_java_setIntField(env, c, obj, "BSEND_OVERHEAD", MPI_BSEND_OVERHEAD);
-    ompi_java_setIntField(env, c, obj, "MAX_OBJECT_NAME", MPI_MAX_OBJECT_NAME);
-    ompi_java_setIntField(env, c, obj, "MAX_PORT_NAME", MPI_MAX_PORT_NAME);
-    ompi_java_setIntField(env, c, obj, "MAX_DATAREP_STRING", MPI_MAX_DATAREP_STRING);
-    ompi_java_setIntField(env, c, obj, "MAX_INFO_KEY", MPI_MAX_INFO_KEY);
-    ompi_java_setIntField(env, c, obj, "MAX_INFO_VAL", MPI_MAX_INFO_VAL);
-    ompi_java_setIntField(env, c, obj, "ORDER_C", MPI_ORDER_C);
-    ompi_java_setIntField(env, c, obj, "ORDER_FORTRAN", MPI_ORDER_FORTRAN);
-    ompi_java_setIntField(env, c, obj, "DISTRIBUTE_BLOCK", MPI_DISTRIBUTE_BLOCK);
-    ompi_java_setIntField(env, c, obj, "DISTRIBUTE_CYCLIC", MPI_DISTRIBUTE_CYCLIC);
-    ompi_java_setIntField(env, c, obj, "DISTRIBUTE_NONE", MPI_DISTRIBUTE_NONE);
-    ompi_java_setIntField(env, c, obj, "DISTRIBUTE_DFLT_DARG", MPI_DISTRIBUTE_DFLT_DARG);
-
-    ompi_java_setIntField(env, c, obj, "MODE_CREATE", MPI_MODE_CREATE);
-    ompi_java_setIntField(env, c, obj, "MODE_RDONLY", MPI_MODE_RDONLY);
-    ompi_java_setIntField(env, c, obj, "MODE_WRONLY", MPI_MODE_WRONLY);
-    ompi_java_setIntField(env, c, obj, "MODE_RDWR", MPI_MODE_RDWR);
-    ompi_java_setIntField(env, c, obj, "MODE_DELETE_ON_CLOSE", MPI_MODE_DELETE_ON_CLOSE);
-    ompi_java_setIntField(env, c, obj, "MODE_UNIQUE_OPEN", MPI_MODE_UNIQUE_OPEN);
-    ompi_java_setIntField(env, c, obj, "MODE_EXCL", MPI_MODE_EXCL);
-    ompi_java_setIntField(env, c, obj, "MODE_APPEND", MPI_MODE_APPEND);
-    ompi_java_setIntField(env, c, obj, "MODE_SEQUENTIAL", MPI_MODE_SEQUENTIAL);
-    ompi_java_setIntField(env, c, obj, "DISPLACEMENT_CURRENT", MPI_DISPLACEMENT_CURRENT);
-    ompi_java_setIntField(env, c, obj, "SEEK_SET", MPI_SEEK_SET);
-    ompi_java_setIntField(env, c, obj, "SEEK_CUR", MPI_SEEK_CUR);
-    ompi_java_setIntField(env, c, obj, "SEEK_END", MPI_SEEK_END);
-
-    ompi_java_setIntField(env, c, obj, "MODE_NOCHECK", MPI_MODE_NOCHECK);
-    ompi_java_setIntField(env, c, obj, "MODE_NOPRECEDE", MPI_MODE_NOPRECEDE);
-    ompi_java_setIntField(env, c, obj, "MODE_NOPUT", MPI_MODE_NOPUT);
-    ompi_java_setIntField(env, c, obj, "MODE_NOSTORE", MPI_MODE_NOSTORE);
-    ompi_java_setIntField(env, c, obj, "MODE_NOSUCCEED", MPI_MODE_NOSUCCEED);
-    ompi_java_setIntField(env, c, obj, "LOCK_EXCLUSIVE", MPI_LOCK_EXCLUSIVE);
-    ompi_java_setIntField(env, c, obj, "LOCK_SHARED", MPI_LOCK_SHARED);
-
-    // Error classes and codes
-    ompi_java_setIntField(env, c, obj, "SUCCESS",          MPI_SUCCESS);
-    ompi_java_setIntField(env, c, obj, "ERR_BUFFER",       MPI_ERR_BUFFER);
-    ompi_java_setIntField(env, c, obj, "ERR_COUNT",        MPI_ERR_COUNT);
-    ompi_java_setIntField(env, c, obj, "ERR_TYPE",         MPI_ERR_TYPE);
-    ompi_java_setIntField(env, c, obj, "ERR_TAG",          MPI_ERR_TAG);
-    ompi_java_setIntField(env, c, obj, "ERR_COMM",         MPI_ERR_COMM);
-    ompi_java_setIntField(env, c, obj, "ERR_RANK",         MPI_ERR_RANK);
-    ompi_java_setIntField(env, c, obj, "ERR_REQUEST",      MPI_ERR_REQUEST);
-    ompi_java_setIntField(env, c, obj, "ERR_ROOT",         MPI_ERR_ROOT);
-    ompi_java_setIntField(env, c, obj, "ERR_GROUP",        MPI_ERR_GROUP);
-    ompi_java_setIntField(env, c, obj, "ERR_OP",           MPI_ERR_OP);
-    ompi_java_setIntField(env, c, obj, "ERR_TOPOLOGY",     MPI_ERR_TOPOLOGY);
-    ompi_java_setIntField(env, c, obj, "ERR_DIMS",         MPI_ERR_DIMS);
-    ompi_java_setIntField(env, c, obj, "ERR_ARG",          MPI_ERR_ARG);
-    ompi_java_setIntField(env, c, obj, "ERR_UNKNOWN",      MPI_ERR_UNKNOWN);
-    ompi_java_setIntField(env, c, obj, "ERR_TRUNCATE",     MPI_ERR_TRUNCATE);
-    ompi_java_setIntField(env, c, obj, "ERR_OTHER",        MPI_ERR_OTHER);
-    ompi_java_setIntField(env, c, obj, "ERR_INTERN",       MPI_ERR_INTERN);
-    ompi_java_setIntField(env, c, obj, "ERR_IN_STATUS",    MPI_ERR_IN_STATUS);
-    ompi_java_setIntField(env, c, obj, "ERR_PENDING",      MPI_ERR_PENDING);
-    ompi_java_setIntField(env, c, obj, "ERR_ACCESS",       MPI_ERR_ACCESS);
-    ompi_java_setIntField(env, c, obj, "ERR_AMODE",        MPI_ERR_AMODE);
-    ompi_java_setIntField(env, c, obj, "ERR_ASSERT",       MPI_ERR_ASSERT);
-    ompi_java_setIntField(env, c, obj, "ERR_BAD_FILE",     MPI_ERR_BAD_FILE);
-    ompi_java_setIntField(env, c, obj, "ERR_BASE",         MPI_ERR_BASE);
-    ompi_java_setIntField(env, c, obj, "ERR_CONVERSION",   MPI_ERR_CONVERSION);
-    ompi_java_setIntField(env, c, obj, "ERR_DISP",         MPI_ERR_DISP);
-    ompi_java_setIntField(env, c, obj, "ERR_DUP_DATAREP",  MPI_ERR_DUP_DATAREP);
-    ompi_java_setIntField(env, c, obj, "ERR_FILE_EXISTS",  MPI_ERR_FILE_EXISTS);
-    ompi_java_setIntField(env, c, obj, "ERR_FILE_IN_USE",  MPI_ERR_FILE_IN_USE);
-    ompi_java_setIntField(env, c, obj, "ERR_FILE",         MPI_ERR_FILE);
-    ompi_java_setIntField(env, c, obj, "ERR_INFO_KEY",     MPI_ERR_INFO_KEY);
-    ompi_java_setIntField(env, c, obj, "ERR_INFO_NOKEY",   MPI_ERR_INFO_NOKEY);
-    ompi_java_setIntField(env, c, obj, "ERR_INFO_VALUE",   MPI_ERR_INFO_VALUE);
-    ompi_java_setIntField(env, c, obj, "ERR_INFO",         MPI_ERR_INFO);
-    ompi_java_setIntField(env, c, obj, "ERR_IO",           MPI_ERR_IO);
-    ompi_java_setIntField(env, c, obj, "ERR_KEYVAL",       MPI_ERR_KEYVAL);
-    ompi_java_setIntField(env, c, obj, "ERR_LOCKTYPE",     MPI_ERR_LOCKTYPE);
-    ompi_java_setIntField(env, c, obj, "ERR_NAME",         MPI_ERR_NAME);
-    ompi_java_setIntField(env, c, obj, "ERR_NO_MEM",       MPI_ERR_NO_MEM);
-    ompi_java_setIntField(env, c, obj, "ERR_NOT_SAME",     MPI_ERR_NOT_SAME);
-    ompi_java_setIntField(env, c, obj, "ERR_NO_SPACE",     MPI_ERR_NO_SPACE);
-    ompi_java_setIntField(env, c, obj, "ERR_NO_SUCH_FILE", MPI_ERR_NO_SUCH_FILE);
-    ompi_java_setIntField(env, c, obj, "ERR_PORT",         MPI_ERR_PORT);
-    ompi_java_setIntField(env, c, obj, "ERR_PROC_ABORTED", MPI_ERR_PROC_ABORTED);
-    ompi_java_setIntField(env, c, obj, "ERR_QUOTA",        MPI_ERR_QUOTA);
-    ompi_java_setIntField(env, c, obj, "ERR_READ_ONLY",    MPI_ERR_READ_ONLY);
-    ompi_java_setIntField(env, c, obj, "ERR_RMA_CONFLICT", MPI_ERR_RMA_CONFLICT);
-    ompi_java_setIntField(env, c, obj, "ERR_RMA_SYNC",     MPI_ERR_RMA_SYNC);
-    ompi_java_setIntField(env, c, obj, "ERR_SERVICE",      MPI_ERR_SERVICE);
-    ompi_java_setIntField(env, c, obj, "ERR_SIZE",         MPI_ERR_SIZE);
-    ompi_java_setIntField(env, c, obj, "ERR_SPAWN",        MPI_ERR_SPAWN);
-
-    ompi_java_setIntField(env, c, obj, "ERR_UNSUPPORTED_DATAREP",
-                          MPI_ERR_UNSUPPORTED_DATAREP);
-
-    ompi_java_setIntField(env, c, obj, "ERR_UNSUPPORTED_OPERATION",
-                          MPI_ERR_UNSUPPORTED_OPERATION);
-
-    ompi_java_setIntField(env, c, obj, "ERR_WIN",          MPI_ERR_WIN);
-    ompi_java_setIntField(env, c, obj, "ERR_LASTCODE",     MPI_ERR_LASTCODE);
-}
diff --git a/ompi/mpi/java/c/mpi_Count.c b/ompi/mpi/java/c/mpi_Count.c
deleted file mode 100644
index 0ef8827c017..00000000000
--- a/ompi/mpi/java/c/mpi_Count.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Version.java
- * Author       : Nathaniel Graham
- * Created      : Thu Jul  30 09:34 2015
- */
-
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Count.h"
-#include "mpiJava.h"
-
-JNIEXPORT void JNICALL Java_mpi_Count_initCount(JNIEnv *env, jclass jthis)
-{
-	jclass c = (*env)->FindClass(env, "mpi/Count");
-	ompi_java.CountClass = (*env)->NewGlobalRef(env, c);
-	ompi_java.CountInit = (*env)->GetMethodID(env, ompi_java.CountClass, "<init>", "(J)V");
-
-	(*env)->DeleteLocalRef(env, c);
-}
diff --git a/ompi/mpi/java/c/mpi_Datatype.c b/ompi/mpi/java/c/mpi_Datatype.c
deleted file mode 100644
index 0f8be98a7e5..00000000000
--- a/ompi/mpi/java/c/mpi_Datatype.c
+++ /dev/null
@@ -1,367 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2016      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      Research Organization for Information Science
- *                         and Technology (RIST).  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_Datatype.c
- * Headerfile   : mpi_Datatype.h
- * Author       : Sung-Hoon Ko, Xinying Li, Sang Lim, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.10 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Datatype.h"
-#include "mpiJava.h"
-
-MPI_Datatype Dts[] = { MPI_DATATYPE_NULL,  /* NULL */
-                       MPI_UINT8_T,  /* BYTE */
-                       MPI_UINT16_T, /* CHAR */
-                       MPI_INT16_T,  /* SHORT */
-                       MPI_UINT8_T,  /* BOOLEAN (let's hope Java is
-                                        one byte..) */
-                       MPI_INT32_T,  /* INT */
-                       MPI_INT64_T,  /* LONG */
-                       MPI_FLOAT,    /* FLOAT (let's hope it's the same!) */
-                       MPI_DOUBLE,   /* DOUBLE (let's hoe it's the same!) */
-                       MPI_PACKED,   /* PACKED */
-                       MPI_2INT,
-                       MPI_SHORT_INT,
-                       MPI_LONG_INT,
-                       MPI_FLOAT_INT,
-                       MPI_DOUBLE_INT,
-                       MPI_C_FLOAT_COMPLEX,
-                       MPI_C_DOUBLE_COMPLEX
-};
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_init(JNIEnv *e, jclass clazz)
-{
-    ompi_java.DatatypeHandle   = (*e)->GetFieldID(e, clazz, "handle",   "J");
-    ompi_java.DatatypeBaseType = (*e)->GetFieldID(e, clazz, "baseType", "I");
-    ompi_java.DatatypeBaseSize = (*e)->GetFieldID(e, clazz, "baseSize", "I");
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getDatatype(
-                        JNIEnv *e, jobject jthis, jint type)
-{
-    return (jlong)Dts[type];
-}
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_getLbExtent(
-        JNIEnv *env, jobject jthis, jlong type, jintArray jLbExt)
-{
-    MPI_Aint lb, extent;
-    int rc = MPI_Type_get_extent((MPI_Datatype)type, &lb, &extent);
-    if(ompi_java_exceptionCheck(env, rc))
-        return;
-
-    jint *lbExt = (*env)->GetIntArrayElements(env, jLbExt, NULL);
-    lbExt[0] = (jint)lb;
-    lbExt[1] = (jint)extent;
-    (*env)->ReleaseIntArrayElements(env, jLbExt, lbExt, 0);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_getTrueLbExtent(
-        JNIEnv *env, jobject jthis, jlong type, jintArray jLbExt)
-{
-    MPI_Aint lb, extent;
-    int rc = MPI_Type_get_true_extent((MPI_Datatype)type, &lb, &extent);
-    if(ompi_java_exceptionCheck(env, rc))
-        return;
-
-    jint *lbExt = (*env)->GetIntArrayElements(env, jLbExt, NULL);
-    lbExt[0] = (jint)lb;
-    lbExt[1] = (jint)extent;
-    (*env)->ReleaseIntArrayElements(env, jLbExt, lbExt, 0);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Datatype_getSize(
-        JNIEnv *env, jobject jthis, jlong type)
-{
-    int rc, result;
-    rc = MPI_Type_size((MPI_Datatype)type, &result);
-    ompi_java_exceptionCheck(env, rc);
-    return result;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_commit(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Datatype type = (MPI_Datatype)handle;
-    int rc = MPI_Type_commit(&type);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_free(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Datatype type = (MPI_Datatype)handle;
-
-    if(type != MPI_DATATYPE_NULL)
-    {
-        int rc = MPI_Type_free(&type);
-        ompi_java_exceptionCheck(env, rc);
-    }
-
-    return (jlong)type;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_dup(
-        JNIEnv *env, jobject jthis, jlong oldType)
-{
-    MPI_Datatype newType;
-    int rc = MPI_Type_dup((MPI_Datatype)oldType, &newType);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newType;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getContiguous(
-        JNIEnv *env, jclass clazz, jint count, jlong oldType)
-{
-    MPI_Datatype type;
-    int rc = MPI_Type_contiguous(count, (MPI_Datatype)oldType, &type);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)type;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getVector(
-            JNIEnv *env, jclass clazz, jint count,
-            jint blockLength, jint stride, jlong oldType)
-{
-    MPI_Datatype type;
-
-    int rc = MPI_Type_vector(count, blockLength, stride,
-                             (MPI_Datatype)oldType, &type);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)type;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getHVector(
-        JNIEnv *env, jclass clazz, jint count,
-        jint blockLength, jint stride, jlong oldType)
-{
-    MPI_Datatype type;
-
-    int rc = MPI_Type_create_hvector(count, blockLength, stride,
-                                     (MPI_Datatype)oldType, &type);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)type;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getIndexed(
-        JNIEnv *env, jclass clazz, jintArray blockLengths,
-        jintArray disps, jlong oldType)
-{
-    MPI_Datatype type;
-    int count = (*env)->GetArrayLength(env, blockLengths);
-
-    jint *jBlockLengths, *jDispl;
-    int  *cBlockLengths, *cDispl;
-    ompi_java_getIntArray(env, blockLengths, &jBlockLengths, &cBlockLengths);
-    ompi_java_getIntArray(env, disps, &jDispl, &cDispl);
-
-    int rc = MPI_Type_indexed(count, cBlockLengths, cDispl,
-                              (MPI_Datatype)oldType, &type);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, blockLengths, jBlockLengths, cBlockLengths);
-    ompi_java_forgetIntArray(env, disps, jDispl, cDispl);
-    return (jlong)type;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getHIndexed(
-        JNIEnv *env, jclass clazz, jintArray blockLengths,
-        jintArray disps, jlong oldType)
-{
-    MPI_Datatype type;
-    int count = (*env)->GetArrayLength(env, blockLengths);
-    jint *jBlockLengths;
-    int  *cBlockLengths;
-    ompi_java_getIntArray(env, blockLengths, &jBlockLengths, &cBlockLengths);
-
-    jint     *jDisps = (*env)->GetIntArrayElements(env, disps, NULL);
-    MPI_Aint *cDisps = (MPI_Aint*)calloc(count, sizeof(MPI_Aint));
-    int i;
-
-    for(i = 0; i < count; i++)
-        cDisps[i] = jDisps[i];
-
-    int rc = MPI_Type_create_hindexed(count, cBlockLengths, cDisps,
-                               (MPI_Datatype)oldType, &type);
-
-    ompi_java_exceptionCheck(env, rc);
-    free(cDisps);
-    ompi_java_forgetIntArray(env, blockLengths, jBlockLengths, cBlockLengths);
-    (*env)->ReleaseIntArrayElements(env, disps, jDisps, JNI_ABORT);
-    return (jlong)type;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getStruct(
-        JNIEnv *env, jclass clazz, jintArray blockLengths,
-        jintArray disps, jobjectArray datatypes)
-{
-    int count = (*env)->GetArrayLength(env, blockLengths);
-    jint *jBlockLengths;
-    int  *cBlockLengths;
-    ompi_java_getIntArray(env, blockLengths, &jBlockLengths, &cBlockLengths);
-
-    jint     *jDisps = (*env)->GetIntArrayElements(env, disps, NULL);
-    MPI_Aint *cDisps = (MPI_Aint*)calloc(count, sizeof(MPI_Aint));
-
-    MPI_Datatype *cTypes = (MPI_Datatype*)calloc(count, sizeof(MPI_Datatype));
-    int i;
-
-    for(i = 0; i < count; i++)
-    {
-        cDisps[i] = jDisps[i];
-        jobject type = (*env)->GetObjectArrayElement(env, datatypes, i);
-
-        cTypes[i] = (MPI_Datatype)(*env)->GetLongField(
-                    env, type, ompi_java.DatatypeHandle);
-
-        (*env)->DeleteLocalRef(env, type);
-    }
-
-    MPI_Datatype type;
-    int rc = MPI_Type_create_struct(count, cBlockLengths, cDisps, cTypes, &type);
-    ompi_java_exceptionCheck(env, rc);
-
-    free(cDisps);
-    free(cTypes);
-    ompi_java_forgetIntArray(env, blockLengths, jBlockLengths, cBlockLengths);
-    (*env)->ReleaseIntArrayElements(env, disps, jDisps, JNI_ABORT);
-    return (jlong)type;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Datatype_getResized(
-        JNIEnv *env, jclass clazz, jlong oldType, jint lb, jint extent)
-{
-    MPI_Datatype type;
-    int rc = MPI_Type_create_resized((MPI_Datatype)oldType, lb, extent, &type);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)type;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_setName(
-        JNIEnv *env, jobject jthis, jlong handle, jstring jname)
-{
-    const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
-    int rc = MPI_Type_set_name((MPI_Datatype)handle, (char*)name);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jname, name);
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_Datatype_getName(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    char name[MPI_MAX_OBJECT_NAME];
-    int len;
-    int rc = MPI_Type_get_name((MPI_Datatype)handle, name, &len);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    return (*env)->NewStringUTF(env, name);
-}
-
-static int typeCopyAttr(MPI_Datatype oldType, int keyval, void *extraState,
-                        void *attrValIn, void *attrValOut, int *flag)
-{
-    return ompi_java_attrCopy(attrValIn, attrValOut, flag);
-}
-
-static int typeDeleteAttr(MPI_Datatype oldType, int keyval,
-                          void *attrVal, void *extraState)
-{
-    return ompi_java_attrDelete(attrVal);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Datatype_createKeyval_1jni(
-                       JNIEnv *env, jclass clazz)
-{
-    int rc, keyval;
-    rc = MPI_Type_create_keyval(typeCopyAttr, typeDeleteAttr, &keyval, NULL);
-    ompi_java_exceptionCheck(env, rc);
-    return keyval;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_freeKeyval_1jni(
-                       JNIEnv *env, jclass clazz, jint keyval)
-{
-    int rc = MPI_Type_free_keyval((int*)(&keyval));
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_setAttr(
-        JNIEnv *env, jobject jthis, jlong type, jint keyval, jbyteArray jval)
-{
-    void *cval = ompi_java_attrSet(env, jval);
-    int rc = MPI_Type_set_attr((MPI_Datatype)type, keyval, cval);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Datatype_getAttr(
-        JNIEnv *env, jobject jthis, jlong type, jint keyval)
-{
-    int flag;
-    void *val;
-    int rc = MPI_Type_get_attr((MPI_Datatype)type, keyval, &val, &flag);
-
-    if(ompi_java_exceptionCheck(env, rc) || !flag)
-        return NULL;
-
-    return ompi_java_attrGet(env, val);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Datatype_deleteAttr(
-        JNIEnv *env, jobject jthis, jlong type, jint keyval)
-{
-    int rc = MPI_Type_delete_attr((MPI_Datatype)type, keyval);
-    ompi_java_exceptionCheck(env, rc);
-}
diff --git a/ompi/mpi/java/c/mpi_Errhandler.c b/ompi/mpi/java/c/mpi_Errhandler.c
deleted file mode 100644
index de09b13a619..00000000000
--- a/ompi/mpi/java/c/mpi_Errhandler.c
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2020 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-
-/*
- * File         : mpi_Errhandler.c
- * Headerfile   : mpi_Errhandler.h
- * Author       : Bryan Carpenter
- * Created      : 1999
- * Revision     : $Revision: 1.2 $
- * Updated      : $Date: 2001/08/07 16:36:15 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-#include "ompi_config.h"
-
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include  <mpi.h>
-#include "mpi_Errhandler.h"
-#include "mpiJava.h"
-
-JNIEXPORT jlong JNICALL Java_mpi_Errhandler_getFatal(JNIEnv *env, jclass clazz)
-{
-    return (jlong)MPI_ERRORS_ARE_FATAL;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Errhandler_getAbort(JNIEnv *env, jclass clazz)
-{
-    return (jlong)MPI_ERRORS_ABORT;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Errhandler_getReturn(JNIEnv *env, jclass clazz)
-{
-    return (jlong)MPI_ERRORS_RETURN;
-}
diff --git a/ompi/mpi/java/c/mpi_File.c b/ompi/mpi/java/c/mpi_File.c
deleted file mode 100644
index 237b522776b..00000000000
--- a/ompi/mpi/java/c/mpi_File.c
+++ /dev/null
@@ -1,745 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2016      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#include <assert.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_File.h"
-#include "mpiJava.h"
-
-JNIEXPORT jlong JNICALL Java_mpi_File_open(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jstring jfilename, jint amode, jlong info)
-{
-    const char* filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
-    MPI_File fh;
-
-    int rc = MPI_File_open((MPI_Comm)comm, (char*)filename,
-                           amode, (MPI_Info)info, &fh);
-
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jfilename, filename);
-    return (jlong)fh;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_close(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    MPI_File file = (MPI_File)fh;
-    int rc = MPI_File_close(&file);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)file;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_delete(
-        JNIEnv *env, jclass clazz, jstring jfilename, jlong info)
-{
-    const char* filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
-    int rc = MPI_File_delete((char*)filename, (MPI_Info)info);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jfilename, filename);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_setSize(
-        JNIEnv *env, jobject jthis, jlong fh, jlong size)
-{
-    int rc = MPI_File_set_size((MPI_File)fh, (MPI_Offset)size);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_preallocate(
-        JNIEnv *env, jobject jthis, jlong fh, jlong size)
-{
-    int rc = MPI_File_preallocate((MPI_File)fh, (MPI_Offset)size);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_getSize(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    MPI_Offset size;
-    int rc = MPI_File_get_size((MPI_File)fh, &size);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)size;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_getGroup(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    MPI_Group group;
-    int rc = MPI_File_get_group((MPI_File)fh, &group);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)group;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_File_getAMode(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    int amode;
-    int rc = MPI_File_get_amode((MPI_File)fh, &amode);
-    ompi_java_exceptionCheck(env, rc);
-    return amode;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_setInfo(
-        JNIEnv *env, jobject jthis, jlong fh, jlong info)
-{
-    int rc = MPI_File_set_info((MPI_File)fh, (MPI_Info)info);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_getInfo(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    MPI_Info info;
-    int rc = MPI_File_get_info((MPI_File)fh, &info);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)info;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_setView(
-        JNIEnv *env, jobject jthis, jlong fh, jlong disp,
-        jlong etype, jlong filetype, jstring jdatarep, jlong info)
-{
-    const char* datarep = (*env)->GetStringUTFChars(env, jdatarep, NULL);
-
-    int rc = MPI_File_set_view(
-            (MPI_File)fh, (MPI_Offset)disp, (MPI_Datatype)etype,
-            (MPI_Datatype)filetype, (char*)datarep, (MPI_Info)info);
-
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jdatarep, datarep);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readAt(
-        JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
-        jobject buf, jboolean db, jint off, jint count,
-        jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-    MPI_Status status;
-
-    int rc = MPI_File_read_at((MPI_File)fh, (MPI_Offset)fileOffset,
-                              ptr, count, type, &status);
-
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseWritePtr(ptr, item, env, buf, db, off, count, type, bType);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readAtAll(
-        JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
-        jobject buf, jboolean db, jint off, jint count,
-        jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-    MPI_Status status;
-
-    int rc = MPI_File_read_at_all((MPI_File)fh, (MPI_Offset)fileOffset,
-                                  ptr, count, type, &status);
-
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseWritePtr(ptr, item, env, buf, db, off, count, type, bType);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeAt(
-        JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
-        jobject buf, jboolean db, jint off, jint count,
-        jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType);
-    MPI_Status status;
-
-    int rc = MPI_File_write_at((MPI_File)fh, (MPI_Offset)fileOffset,
-                               ptr, count, type, &status);
-
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeAtAll(
-        JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
-        jobject buf, jboolean db, jint off, jint count,
-        jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType);
-    MPI_Status status;
-
-    int rc = MPI_File_write_at_all((MPI_File)fh, (MPI_Offset)fileOffset,
-                                   ptr, count, (MPI_Datatype)type, &status);
-
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iReadAt(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iread_at((MPI_File)fh, (MPI_Offset)offset,
-                               ptr, count, (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iReadAtAll(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iread_at_all((MPI_File)fh, (MPI_Offset)offset,
-                                   ptr, count, (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iWriteAt(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iwrite_at((MPI_File)fh, (MPI_Offset)offset,
-                                ptr, count, (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iWriteAtAll(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iwrite_at_all((MPI_File)fh, (MPI_Offset)offset,
-                                    ptr, count, (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_read(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-    MPI_Status status;
-    int rc = MPI_File_read((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseWritePtr(ptr, item, env, buf, db, off, count, type, bType);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readAll(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-    MPI_Status status;
-    int rc = MPI_File_read_all((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseWritePtr(ptr, item, env, buf, db, off, count, type, bType);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_write(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType);
-    MPI_Status status;
-    int rc = MPI_File_write((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeAll(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType);
-    MPI_Status status;
-    int rc = MPI_File_write_all((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iRead(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iread((MPI_File)fh, ptr, count,
-                            (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iReadAll(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iread_all((MPI_File)fh, ptr, count,
-                                (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iWrite(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iwrite((MPI_File)fh, ptr, count,
-                             (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iWriteAll(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iwrite_all((MPI_File)fh, ptr, count,
-                                 (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_seek(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset, jint whence)
-{
-    int rc = MPI_File_seek((MPI_File)fh, (MPI_Offset)offset, whence);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_getPosition(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    MPI_Offset offset;
-    int rc = MPI_File_get_position((MPI_File)fh, &offset);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)offset;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_getByteOffset(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset)
-{
-    MPI_Offset disp;
-    int rc = MPI_File_get_byte_offset((MPI_File)fh, (MPI_Offset)offset, &disp);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)disp;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readShared(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-    MPI_Status status;
-    int rc = MPI_File_read_shared((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseWritePtr(ptr, item, env, buf, db, off, count, type, bType);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeShared(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType);
-    MPI_Status status;
-    int rc = MPI_File_write_shared((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iReadShared(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iread_shared((MPI_File)fh, ptr, count,
-                                   (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_iWriteShared(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    MPI_Request request;
-
-    int rc = MPI_File_iwrite_shared((MPI_File)fh, ptr, count,
-                                    (MPI_Datatype)type, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readOrdered(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-    MPI_Status status;
-    int rc = MPI_File_read_ordered((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseWritePtr(ptr, item, env, buf, db, off, count, type, bType);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeOrdered(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray stat)
-{
-    jboolean exception;
-    MPI_Datatype type = (MPI_Datatype)jType;
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getReadPtr(&ptr, &item, env, buf, db, off, count, type, bType);
-    MPI_Status status;
-    int rc = MPI_File_write_ordered((MPI_File)fh, ptr, count, type, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseReadPtr(ptr, item, buf, db);
-    
-    if(!exception)
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_seekShared(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset, jint whence)
-{
-    int rc = MPI_File_seek_shared((MPI_File)fh, (MPI_Offset)offset, whence);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_getPositionShared(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    MPI_Offset offset;
-    int rc = MPI_File_get_position_shared((MPI_File)fh, &offset);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)offset;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readAtAllBegin(
-        JNIEnv *env, jobject jthis, jlong fh, jlong offset,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-
-    int rc = MPI_File_read_at_all_begin((MPI_File)fh, (MPI_Offset)offset,
-                                        ptr, count, (MPI_Datatype)type);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readAtAllEnd(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jlongArray stat)
-{
-    MPI_Status status;
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    int rc = MPI_File_read_at_all_end((MPI_File)fh, ptr, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeAtAllBegin(
-        JNIEnv *env, jobject jthis, jlong fh, jlong fileOffset,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-
-    int rc = MPI_File_write_at_all_begin((MPI_File)fh, (MPI_Offset)fileOffset,
-                                         ptr, count, (MPI_Datatype)type);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeAtAllEnd(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jlongArray stat)
-{
-    MPI_Status status;
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    int rc = MPI_File_write_at_all_end((MPI_File)fh, ptr, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readAllBegin(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-
-    int rc = MPI_File_read_all_begin(
-             (MPI_File)fh, ptr, count, (MPI_Datatype)type);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readAllEnd(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jlongArray stat)
-{
-    MPI_Status status;
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    int rc = MPI_File_read_all_end((MPI_File)fh, ptr, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeAllBegin(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-
-    int rc = MPI_File_write_all_begin(
-             (MPI_File)fh, ptr, count, (MPI_Datatype)type);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeAllEnd(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jlongArray stat)
-{
-    MPI_Status status;
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    int rc = MPI_File_write_all_end((MPI_File)fh, ptr, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readOrderedBegin(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-
-    int rc = MPI_File_read_ordered_begin(
-             (MPI_File)fh, ptr, count, (MPI_Datatype)type);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_readOrderedEnd(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jlongArray stat)
-{
-    MPI_Status status;
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    int rc = MPI_File_read_ordered_end((MPI_File)fh, ptr, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeOrderedBegin(
-        JNIEnv *env, jobject jthis, jlong fh,
-        jobject buf, jint count, jlong type)
-{
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-
-    int rc = MPI_File_write_ordered_begin(
-             (MPI_File)fh, ptr, count, (MPI_Datatype)type);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_writeOrderedEnd(
-        JNIEnv *env, jobject jthis, jlong fh, jobject buf, jlongArray stat)
-{
-    MPI_Status status;
-    void *ptr = (*env)->GetDirectBufferAddress(env, buf);
-    int rc = MPI_File_write_ordered_end((MPI_File)fh, ptr, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, stat, &status);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_File_getTypeExtent(
-        JNIEnv *env, jobject jthis, jlong fh, jlong type)
-{
-    MPI_Aint extent;
-
-    int rc = MPI_File_get_type_extent(
-             (MPI_File)fh, (MPI_Datatype)type, &extent);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (int)extent;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_setAtomicity(
-        JNIEnv *env, jobject jthis, jlong fh, jboolean atomicity)
-{
-    int rc = MPI_File_set_atomicity((MPI_File)fh, atomicity);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_File_getAtomicity(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    int atomicity;
-    int rc = MPI_File_get_atomicity((MPI_File)fh, &atomicity);
-    ompi_java_exceptionCheck(env, rc);
-    return atomicity ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_sync(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    int rc = MPI_File_sync((MPI_File)fh);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_setErrhandler(
-        JNIEnv *env, jobject jthis, jlong fh, jlong errhandler)
-{
-    int rc = MPI_File_set_errhandler(
-             (MPI_File)fh, (MPI_Errhandler)errhandler);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_File_getErrhandler(
-        JNIEnv *env, jobject jthis, jlong fh)
-{
-    MPI_Errhandler errhandler;
-    int rc = MPI_File_get_errhandler((MPI_File)fh, &errhandler);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)errhandler;
-}
-
-JNIEXPORT void JNICALL Java_mpi_File_callErrhandler(
-        JNIEnv *env, jobject jthis, jlong fh, jint errorCode)
-{
-    int rc = MPI_File_call_errhandler((MPI_File)fh, errorCode);
-    ompi_java_exceptionCheck(env, rc);
-}
diff --git a/ompi/mpi/java/c/mpi_GraphComm.c b/ompi/mpi/java/c/mpi_GraphComm.c
deleted file mode 100644
index 8a77eb816d4..00000000000
--- a/ompi/mpi/java/c/mpi_GraphComm.c
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_GraphComm.c
- * Headerfile   : mpi_GraphComm.h
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.2 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-#include "ompi_config.h"
-
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_GraphComm.h"
-#include "mpiJava.h"
-
-JNIEXPORT void JNICALL Java_mpi_GraphComm_init(JNIEnv *env, jclass clazz)
-{
-    ompi_java.GraphParmsInit = (*env)->GetMethodID(env,
-            ompi_java.GraphParmsClass, "<init>", "([I[I)V");
-    ompi_java.DistGraphNeighborsInit = (*env)->GetMethodID(env,
-            ompi_java.DistGraphNeighborsClass, "<init>", "([I[I[I[IZ)V");
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_GraphComm_getDims(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    int maxInd, maxEdg;
-    int rc = MPI_Graphdims_get((MPI_Comm)comm, &maxInd, &maxEdg);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    jintArray index = (*env)->NewIntArray(env, maxInd),
-              edges = (*env)->NewIntArray(env, maxEdg);
-
-    jint *jIndex, *jEdges;
-    int  *cIndex, *cEdges;
-    ompi_java_getIntArray(env, index, &jIndex, &cIndex);
-    ompi_java_getIntArray(env, edges, &jEdges, &cEdges);
-
-    rc = MPI_Graph_get((MPI_Comm)comm, maxInd, maxEdg, cIndex, cEdges);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseIntArray(env, index, jIndex, cIndex);
-    ompi_java_releaseIntArray(env, edges, jEdges, cEdges);
-
-    return (*env)->NewObject(env, ompi_java.GraphParmsClass,
-                             ompi_java.GraphParmsInit, index, edges);
-}
-
-JNIEXPORT jintArray JNICALL Java_mpi_GraphComm_getNeighbors(
-        JNIEnv *env, jobject jthis, jlong comm, jint rank)
-{
-    int maxNs;
-    int rc = MPI_Graph_neighbors_count((MPI_Comm)comm, rank, &maxNs);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    jintArray neighbors = (*env)->NewIntArray(env, maxNs);
-    jint *jNeighbors;
-    int  *cNeighbors;
-    ompi_java_getIntArray(env, neighbors, &jNeighbors, &cNeighbors);
-
-    rc = MPI_Graph_neighbors((MPI_Comm)comm, rank, maxNs, cNeighbors);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseIntArray(env, neighbors, jNeighbors, cNeighbors);
-    return neighbors;
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_GraphComm_getDistGraphNeighbors(
-        JNIEnv *env, jobject jthis, jlong comm)
-{
-    int inDegree, outDegree, weighted;
-
-    int rc = MPI_Dist_graph_neighbors_count(
-             (MPI_Comm)comm, &inDegree, &outDegree, &weighted);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    jintArray sources      = (*env)->NewIntArray(env, inDegree),
-              srcWeights   = (*env)->NewIntArray(env, inDegree),
-              destinations = (*env)->NewIntArray(env, outDegree),
-              destWeights  = (*env)->NewIntArray(env, outDegree);
-
-    jint *jSources, *jSrcWeights, *jDestinations, *jDestWeights;
-    int  *cSources, *cSrcWeights, *cDestinations, *cDestWeights;
-
-    ompi_java_getIntArray(env, sources,      &jSources,      &cSources);
-    ompi_java_getIntArray(env, srcWeights,   &jSrcWeights,   &cSrcWeights);
-    ompi_java_getIntArray(env, destinations, &jDestinations, &cDestinations);
-    ompi_java_getIntArray(env, destWeights,  &jDestWeights,  &cDestWeights);
-
-    rc = MPI_Dist_graph_neighbors((MPI_Comm)comm,
-            inDegree, cSources, cSrcWeights,
-            outDegree, cDestinations, cDestWeights);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releaseIntArray(env, sources,      jSources,      cSources);
-    ompi_java_releaseIntArray(env, srcWeights,   jSrcWeights,   cSrcWeights);
-    ompi_java_releaseIntArray(env, destinations, jDestinations, cDestinations);
-    ompi_java_releaseIntArray(env, destWeights,  jDestWeights,  cDestWeights);
-
-    return (*env)->NewObject(env,
-           ompi_java.DistGraphNeighborsClass, ompi_java.DistGraphNeighborsInit,
-           sources, srcWeights, destinations, destWeights,
-           weighted ? JNI_TRUE : JNI_FALSE);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_GraphComm_map(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jintArray index, jintArray edges)
-{
-    int nNodes = (*env)->GetArrayLength(env, index);
-    jint *jIndex, *jEdges;
-    int  *cIndex, *cEdges;
-    ompi_java_getIntArray(env, index, &jIndex, &cIndex);
-    ompi_java_getIntArray(env, edges, &jEdges, &cEdges);
-
-    int newrank;
-    int rc = MPI_Graph_map((MPI_Comm)comm, nNodes, cIndex, cEdges, &newrank);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_releaseIntArray(env, index, jIndex, cIndex);
-    ompi_java_releaseIntArray(env, edges, jEdges, cEdges);
-    return newrank;
-}
diff --git a/ompi/mpi/java/c/mpi_Group.c b/ompi/mpi/java/c/mpi_Group.c
deleted file mode 100644
index 2ea29f4acdb..00000000000
--- a/ompi/mpi/java/c/mpi_Group.c
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_Group.c
- * Headerfile   : mpi_Group.h
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.3 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Group.h"
-#include "mpiJava.h"
-
-JNIEXPORT void JNICALL Java_mpi_Group_init(JNIEnv *env, jclass clazz)
-{
-    ompi_java_setStaticLongField(env, clazz,
-            "nullHandle", (jlong)MPI_GROUP_NULL);
-
-    ompi_java.GroupHandle = (*env)->GetFieldID(env, clazz, "handle", "J");
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_getEmpty(JNIEnv *env, jclass clazz)
-{
-    return (jlong)MPI_GROUP_EMPTY;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Group_getSize(
-        JNIEnv *env, jobject jthis, jlong group)
-{
-    int size, rc;
-    rc = MPI_Group_size((MPI_Group)group, &size);
-    ompi_java_exceptionCheck(env, rc);
-    return size;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Group_getRank(
-        JNIEnv *env, jobject jthis, jlong group)
-{
-    int rank, rc;
-    rc = MPI_Group_rank((MPI_Group)group, &rank);
-    ompi_java_exceptionCheck(env, rc);
-    return rank;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_free(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Group group = (MPI_Group)handle;
-    int rc = MPI_Group_free(&group);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)group;
-}
-
-JNIEXPORT jintArray JNICALL Java_mpi_Group_translateRanks(
-        JNIEnv *env, jclass jthis, jlong group1,
-        jintArray ranks1, jlong group2)
-{
-    jsize n = (*env)->GetArrayLength(env, ranks1);
-    jintArray ranks2 = (*env)->NewIntArray(env,n);
-    jint *jRanks1, *jRanks2;
-    int  *cRanks1, *cRanks2;
-    ompi_java_getIntArray(env, ranks1, &jRanks1, &cRanks1);
-    ompi_java_getIntArray(env, ranks2, &jRanks2, &cRanks2);
-
-    int rc = MPI_Group_translate_ranks((MPI_Group)group1, n, cRanks1,
-                                       (MPI_Group)group2, cRanks2);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, ranks1, jRanks1, cRanks1);
-    ompi_java_releaseIntArray(env, ranks2, jRanks2, cRanks2);
-    return ranks2;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Group_compare(
-        JNIEnv *env, jclass jthis, jlong group1, jlong group2)
-{
-    int result, rc;
-    rc = MPI_Group_compare((MPI_Group)group1, (MPI_Group)group2, &result);
-    ompi_java_exceptionCheck(env, rc);
-    return result;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_union(
-        JNIEnv *env, jclass jthis, jlong group1, jlong group2)
-{
-    MPI_Group newGroup;
-    int rc = MPI_Group_union((MPI_Group)group1, (MPI_Group)group2, &newGroup);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newGroup;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_intersection(
-        JNIEnv *env, jclass jthis, jlong group1, jlong group2)
-{
-    MPI_Group newGroup;
-
-    int rc = MPI_Group_intersection(
-             (MPI_Group)group1, (MPI_Group)group2, &newGroup);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newGroup;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_difference(
-        JNIEnv *env, jclass jthis, jlong group1, jlong group2)
-{
-    MPI_Group newGroup;
-
-    int rc = MPI_Group_difference(
-             (MPI_Group)group1, (MPI_Group)group2, &newGroup);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newGroup;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_incl(
-        JNIEnv *env, jobject jthis, jlong group, jintArray ranks)
-{
-    jsize n = (*env)->GetArrayLength(env, ranks);
-    jint *jRanks;
-    int  *cRanks;
-    ompi_java_getIntArray(env, ranks, &jRanks, &cRanks);
-
-    MPI_Group newGroup;
-    int rc = MPI_Group_incl((MPI_Group)group, n, cRanks, &newGroup);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_forgetIntArray(env, ranks, jRanks, cRanks);
-    return (jlong)newGroup;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_excl(
-        JNIEnv *env, jobject jthis, jlong group, jintArray ranks)
-{
-    jsize n = (*env)->GetArrayLength(env, ranks);
-    jint *jRanks;
-    int  *cRanks;
-    ompi_java_getIntArray(env, ranks, &jRanks, &cRanks);
-
-    MPI_Group newGroup;
-    int rc = MPI_Group_excl((MPI_Group)group, n, cRanks, &newGroup);
-    ompi_java_exceptionCheck(env, rc);
-
-    ompi_java_forgetIntArray(env, ranks, jRanks, cRanks);
-    return (jlong)newGroup;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_rangeIncl(
-        JNIEnv *env, jobject jthis, jlong group, jobjectArray ranges)
-{
-    int i;
-    MPI_Group newGroup;
-    jsize n = (*env)->GetArrayLength(env, ranges);
-    int (*cRanges)[3] = (int(*)[3])calloc(n, sizeof(int[3]));
-
-    for(i = 0; i < n; i++)
-    {
-        jintArray ri = (*env)->GetObjectArrayElement(env, ranges, i);
-        jint *jri = (*env)->GetIntArrayElements(env, ri, NULL);
-        cRanges[i][0] = jri[0];
-        cRanges[i][1] = jri[1];
-        cRanges[i][2] = jri[2];
-        (*env)->ReleaseIntArrayElements(env, ri, jri, JNI_ABORT);
-        (*env)->DeleteLocalRef(env, ri);
-    }
-
-    int rc = MPI_Group_range_incl((MPI_Group)group, n, cRanges, &newGroup);
-    ompi_java_exceptionCheck(env, rc);
-    free(cRanges);
-    return (jlong)newGroup;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Group_rangeExcl(
-        JNIEnv *env, jobject jthis, jlong group, jobjectArray ranges)
-{
-    int i;
-    MPI_Group newGroup;
-    jsize n = (*env)->GetArrayLength(env, ranges);
-    int (*cRanges)[3] = (int(*)[3])calloc(n, sizeof(int[3]));
-
-    for(i = 0; i < n; i++)
-    {
-        jintArray ri = (*env)->GetObjectArrayElement(env, ranges, i);
-        jint *jri = (*env)->GetIntArrayElements(env, ri, NULL);
-        cRanges[i][0] = jri[0];
-        cRanges[i][1] = jri[1];
-        cRanges[i][2] = jri[2];
-        (*env)->ReleaseIntArrayElements(env, ri, jri, JNI_ABORT);
-        (*env)->DeleteLocalRef(env, ri);
-    }
-
-    int rc = MPI_Group_range_excl((MPI_Group)group, n, cRanges, &newGroup);
-    ompi_java_exceptionCheck(env, rc);
-    free(cRanges);
-    return (jlong)newGroup;
-}
diff --git a/ompi/mpi/java/c/mpi_Info.c b/ompi/mpi/java/c/mpi_Info.c
deleted file mode 100644
index 2bfdc5e8597..00000000000
--- a/ompi/mpi/java/c/mpi_Info.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Info.h"
-#include "mpiJava.h"
-
-JNIEXPORT jlong JNICALL Java_mpi_Info_create(JNIEnv *env, jobject jthis)
-{
-    MPI_Info info;
-    int rc = MPI_Info_create(&info);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)info;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Info_getEnv(JNIEnv *env, jclass clazz)
-{
-    return (jlong)MPI_INFO_ENV;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Info_getNull(JNIEnv *env, jclass clazz)
-{
-    return (jlong)MPI_INFO_NULL;
-}
-
-// At least some versions of jni.h have a global named "jvalue", and
-// we get a compiler warning if we have a parameter or variable of the
-// same name.  So use "ljvalue" instead.
-JNIEXPORT void JNICALL Java_mpi_Info_set(
-        JNIEnv *env, jobject jthis, jlong handle, jstring jkey, jstring ljvalue)
-{
-    const char *key   = (*env)->GetStringUTFChars(env, jkey,    NULL),
-               *value = (*env)->GetStringUTFChars(env, ljvalue, NULL);
-
-    int rc = MPI_Info_set((MPI_Info)handle, (char*)key, (char*)value);
-    ompi_java_exceptionCheck(env, rc);
-
-    (*env)->ReleaseStringUTFChars(env, jkey,    key);
-    (*env)->ReleaseStringUTFChars(env, ljvalue, value);
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_Info_get(
-        JNIEnv *env, jobject jthis, jlong handle, jstring jkey)
-{
-    MPI_Info info = (MPI_Info)handle;
-    const char *key = (*env)->GetStringUTFChars(env, jkey, NULL);
-
-    int rc, valueLen, flag;
-    rc = MPI_Info_get_valuelen(info, (char*)key, &valueLen, &flag);
-
-    if(ompi_java_exceptionCheck(env, rc) || !flag)
-    {
-        (*env)->ReleaseStringUTFChars(env, jkey, key);
-        return NULL;
-    }
-
-    char *value = (char*)calloc(valueLen + 1, sizeof(char));
-    rc = MPI_Info_get((MPI_Info)info, (char*)key, valueLen, value, &flag);
-    (*env)->ReleaseStringUTFChars(env, jkey, key);
-
-    if(ompi_java_exceptionCheck(env, rc) || !flag)
-    {
-        free(value);
-        return NULL;
-    }
-
-    // At least some versions of jni.h have a global named "jvalue",
-    // and we get a compiler warning if we have a parameter or
-    // variable of the same name.  So use "ljvalue" instead.
-    jstring ljvalue = (*env)->NewStringUTF(env, value);
-    free(value);
-    return ljvalue;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Info_delete(
-        JNIEnv *env, jobject jthis, jlong handle, jstring jkey)
-{
-    const char *key = (*env)->GetStringUTFChars(env, jkey, NULL);
-    int rc = MPI_Info_delete((MPI_Info)handle, (char*)key);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jkey, key);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Info_size(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    int rc, nkeys;
-    rc = MPI_Info_get_nkeys((MPI_Info)handle, &nkeys);
-    ompi_java_exceptionCheck(env, rc);
-    return (jint)nkeys;
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_Info_getKey(
-        JNIEnv *env, jobject jthis, jlong handle, jint i)
-{
-    char key[MPI_MAX_INFO_KEY + 1];
-    int rc = MPI_Info_get_nthkey((MPI_Info)handle, i, key);
-
-    return ompi_java_exceptionCheck(env, rc)
-           ? NULL : (*env)->NewStringUTF(env, key);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Info_dup(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Info newInfo;
-    int rc = MPI_Info_dup((MPI_Info)handle, &newInfo);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newInfo;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Info_free(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Info info = (MPI_Info)handle;
-    int rc = MPI_Info_free(&info);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)info;
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_Info_isNull(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    return (MPI_Info)handle == MPI_INFO_NULL ? JNI_TRUE : JNI_FALSE;
-}
diff --git a/ompi/mpi/java/c/mpi_Intercomm.c b/ompi/mpi/java/c/mpi_Intercomm.c
deleted file mode 100644
index 8e8f1b68e98..00000000000
--- a/ompi/mpi/java/c/mpi_Intercomm.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_Intercomm.c
- * Headerfile   : mpi_Intercomm.h
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.3 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-#include "ompi_config.h"
-
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Intercomm.h"
-#include "mpiJava.h"
-
-
-/*
- * Class:     mpi_Intercomm
- * Method:    getRemoteSize_jni
- * Signature: ()I
- */
-JNIEXPORT jint JNICALL Java_mpi_Intercomm_getRemoteSize_1jni(
-                       JNIEnv *env, jobject jthis)
-{
-    int size, rc;
-
-    rc = MPI_Comm_remote_size(
-         (MPI_Comm)((*env)->GetLongField(env,jthis,ompi_java.CommHandle)),
-         &size);
-
-    ompi_java_exceptionCheck(env, rc);
-    return size;
-}
-
-/*
- * Class:     mpi_Intercomm
- * Method:    getRemoteGroup_jni
- * Signature: ()J
- */
-JNIEXPORT jlong JNICALL Java_mpi_Intercomm_getRemoteGroup_1jni(
-                        JNIEnv *env, jobject jthis)
-{
-    MPI_Group group;
-
-    int rc = MPI_Comm_remote_group(
-             (MPI_Comm)((*env)->GetLongField(env,jthis,ompi_java.CommHandle)),
-             &group);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)group;
-}
-
-/*
- * Class:     mpi_Intercomm
- * Method:    merge_jni
- * Signature: (Z)Lmpi/Intracomm;
- */
-JNIEXPORT jlong JNICALL Java_mpi_Intercomm_merge_1jni(
-                        JNIEnv *env, jobject jthis, jboolean high)
-{
-    MPI_Comm newintracomm;
-
-    int rc = MPI_Intercomm_merge(
-             (MPI_Comm)((*env)->GetLongField(env,jthis,ompi_java.CommHandle)),
-             high, &newintracomm);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newintracomm;
-}
-
-/*
- * Class:     mpi_Intercomm
- * Method:    getParent_jni
- * Signature: ()J
- */
-JNIEXPORT jlong JNICALL Java_mpi_Intercomm_getParent_1jni(
-                        JNIEnv *env, jclass clazz)
-{
-    MPI_Comm parent;
-    int rc = MPI_Comm_get_parent(&parent);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)parent;
-}
diff --git a/ompi/mpi/java/c/mpi_Intracomm.c b/ompi/mpi/java/c/mpi_Intracomm.c
deleted file mode 100644
index f73aa0089df..00000000000
--- a/ompi/mpi/java/c/mpi_Intracomm.c
+++ /dev/null
@@ -1,584 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_Intracomm.c
- * Headerfile   : mpi_Intracomm.h
- * Author       : Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.10 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#include <string.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Comm.h"
-#include "mpi_Intracomm.h"
-#include "mpiJava.h"
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_split(
-        JNIEnv *env, jobject jthis, jlong comm, jint colour, jint key)
-{
-    MPI_Comm newcomm;
-    int rc = MPI_Comm_split((MPI_Comm)comm, colour, key, &newcomm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newcomm;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_splitType(
-        JNIEnv *env, jobject jthis, jlong comm, jint splitType, jint key, jlong info)
-{
-    MPI_Comm newcomm;
-    int rc = MPI_Comm_split_type((MPI_Comm)comm, splitType, key, (MPI_Info)info, &newcomm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newcomm;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_create(
-        JNIEnv *env, jobject jthis, jlong comm, jlong group)
-{
-    MPI_Comm newcomm;
-    int rc = MPI_Comm_create((MPI_Comm)comm, (MPI_Group)group, &newcomm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newcomm;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createGroup(
-        JNIEnv *env, jobject jthis, jlong comm, jlong group, int tag)
-{
-    MPI_Comm newcomm;
-    int rc = MPI_Comm_create_group((MPI_Comm)comm, (MPI_Group)group, tag, &newcomm);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)newcomm;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createCart(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jintArray dims, jbooleanArray periods, jboolean reorder)
-{
-    jint *jDims;
-    int  *cDims;
-    ompi_java_getIntArray(env, dims, &jDims, &cDims);
-
-    jboolean *jPeriods;
-    int      *cPeriods;
-    ompi_java_getBooleanArray(env, periods, &jPeriods, &cPeriods);
-
-    int ndims = (*env)->GetArrayLength(env, dims);
-    MPI_Comm cart;
-
-    int rc = MPI_Cart_create((MPI_Comm)comm, ndims, cDims,
-                             cPeriods, reorder, &cart);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, dims, jDims, cDims);
-    ompi_java_forgetBooleanArray(env, periods, jPeriods, cPeriods);
-    return (jlong)cart;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createGraph(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jintArray index, jintArray edges, jboolean reorder)
-{
-    MPI_Comm graph;
-    int nnodes = (*env)->GetArrayLength(env, index);
-
-    jint *jIndex, *jEdges;
-    int  *cIndex, *cEdges;
-    ompi_java_getIntArray(env, index, &jIndex, &cIndex);
-    ompi_java_getIntArray(env, edges, &jEdges, &cEdges);
-
-    int rc = MPI_Graph_create((MPI_Comm)comm,
-             nnodes, cIndex, cEdges, reorder, &graph);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, index, jIndex, cIndex);
-    ompi_java_forgetIntArray(env, edges, jEdges, cEdges);
-    return (jlong)graph;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createDistGraph(
-        JNIEnv *env, jobject jthis, jlong comm, jintArray sources,
-        jintArray degrees, jintArray destins, jintArray weights,
-        jlong info, jboolean reorder, jboolean weighted)
-{
-    MPI_Comm graph;
-    int nnodes = (*env)->GetArrayLength(env, sources);
-
-    jint *jSources, *jDegrees, *jDestins, *jWeights = NULL;
-    int  *cSources, *cDegrees, *cDestins, *cWeights = MPI_UNWEIGHTED;
-    ompi_java_getIntArray(env, sources, &jSources, &cSources);
-    ompi_java_getIntArray(env, degrees, &jDegrees, &cDegrees);
-    ompi_java_getIntArray(env, destins, &jDestins, &cDestins);
-
-    if(weighted)
-        ompi_java_getIntArray(env, weights, &jWeights, &cWeights);
-
-    int rc = MPI_Dist_graph_create((MPI_Comm)comm,
-             nnodes, cSources, cDegrees, cDestins, cWeights,
-             (MPI_Info)info, reorder, &graph);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, sources, jSources, cSources);
-    ompi_java_forgetIntArray(env, degrees, jDegrees, cDegrees);
-    ompi_java_forgetIntArray(env, destins, jDestins, cDestins);
-
-    if(weighted)
-        ompi_java_forgetIntArray(env, weights, jWeights, cWeights);
-
-    return (jlong)graph;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_createDistGraphAdjacent(
-        JNIEnv *env, jobject jthis, jlong comm, jintArray sources,
-        jintArray srcWeights, jintArray destins, jintArray desWeights,
-        jlong info, jboolean reorder, jboolean weighted)
-{
-    MPI_Comm graph;
-
-    int inDegree  = (*env)->GetArrayLength(env, sources),
-        outDegree = (*env)->GetArrayLength(env, destins);
-
-    jint *jSources, *jDestins, *jSrcWeights, *jDesWeights;
-    int  *cSources, *cDestins, *cSrcWeights, *cDesWeights;
-    ompi_java_getIntArray(env, sources, &jSources, &cSources);
-    ompi_java_getIntArray(env, destins, &jDestins, &cDestins);
-
-    if(weighted)
-    {
-        ompi_java_getIntArray(env, srcWeights, &jSrcWeights, &cSrcWeights);
-        ompi_java_getIntArray(env, desWeights, &jDesWeights, &cDesWeights);
-    }
-    else
-    {
-        jSrcWeights = jDesWeights = NULL;
-        cSrcWeights = cDesWeights = MPI_UNWEIGHTED;
-    }
-
-    int rc = MPI_Dist_graph_create_adjacent((MPI_Comm)comm,
-             inDegree, cSources, cSrcWeights, outDegree, cDestins,
-             cDesWeights, (MPI_Info)info, reorder, &graph);
-
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_forgetIntArray(env, sources, jSources, cSources);
-    ompi_java_forgetIntArray(env, destins, jDestins, cDestins);
-
-    if(weighted)
-    {
-        ompi_java_forgetIntArray(env, srcWeights, jSrcWeights, cSrcWeights);
-        ompi_java_forgetIntArray(env, desWeights, jDesWeights, cDesWeights);
-    }
-
-    return (jlong)graph;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Intracomm_scan(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jobject rBuf, jboolean rdb, jint rOff, jint count,
-        jlong jType, jint bType, jobject jOp, jlong hOp)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    if(sBuf == NULL)
-    {
-        sPtr = MPI_IN_PLACE;
-        ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
-    }
-    else
-    {
-        ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
-    }
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    int rc = MPI_Scan(sPtr, rPtr, count, type, op, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iScan(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jobject recvBuf, jint count,
-        jlong type, int baseType, jobject jOp, jlong hOp)
-{
-    void *sPtr, *rPtr;
-    MPI_Request request;
-
-    if(sendBuf == NULL)
-        sPtr = MPI_IN_PLACE;
-    else
-        sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
-
-    rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
-
-    int rc = MPI_Iscan(sPtr, rPtr, count, (MPI_Datatype)type,
-                       ompi_java_op_getHandle(env, jOp, hOp, baseType),
-                       (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Intracomm_exScan(
-        JNIEnv *env, jobject jthis, jlong jComm,
-        jobject sBuf, jboolean sdb, jint sOff,
-        jobject rBuf, jboolean rdb, jint rOff, jint count,
-        jlong jType, int bType, jobject jOp, jlong hOp)
-{
-    MPI_Comm     comm = (MPI_Comm)jComm;
-    MPI_Datatype type = (MPI_Datatype)jType;
-
-    void *sPtr, *rPtr;
-    ompi_java_buffer_t *sItem, *rItem;
-
-    if(sBuf == NULL)
-    {
-        sPtr = MPI_IN_PLACE;
-        ompi_java_getReadPtr(&rPtr,&rItem,env,rBuf,rdb,rOff,count,type,bType);
-    }
-    else
-    {
-        ompi_java_getReadPtr(&sPtr,&sItem,env,sBuf,sdb,sOff,count,type,bType);
-        ompi_java_getWritePtr(&rPtr, &rItem, env, rBuf, rdb, count, type);
-    }
-
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, bType);
-    int rc = MPI_Exscan(sPtr, rPtr, count, type, op, comm);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(sBuf != NULL)
-        ompi_java_releaseReadPtr(sPtr, sItem, sBuf, sdb);
-
-    ompi_java_releaseWritePtr(rPtr,rItem,env,rBuf,rdb,rOff,count,type,bType);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_iExScan(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jobject sendBuf, jobject recvBuf, jint count,
-        jlong type, int bType, jobject jOp, jlong hOp)
-{
-    void *sPtr, *rPtr;
-
-    if(sendBuf == NULL)
-        sPtr = MPI_IN_PLACE;
-    else
-        sPtr = (*env)->GetDirectBufferAddress(env, sendBuf);
-
-    rPtr = (*env)->GetDirectBufferAddress(env, recvBuf);
-    MPI_Request request;
-
-    int rc = MPI_Iexscan(sPtr, rPtr, count, (MPI_Datatype)type,
-                         ompi_java_op_getHandle(env, jOp, hOp, bType),
-                         (MPI_Comm)comm, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_Intracomm_openPort(
-                          JNIEnv *env, jclass clazz, jlong info)
-{
-    char port[MPI_MAX_PORT_NAME + 1];
-    int rc = MPI_Open_port((MPI_Info)info, port);
-
-    return ompi_java_exceptionCheck(env, rc)
-           ? NULL : (*env)->NewStringUTF(env, port);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Intracomm_closePort_1jni(
-                       JNIEnv *env, jclass clazz, jstring jport)
-{
-    const char *port = (*env)->GetStringUTFChars(env, jport, NULL);
-    int rc = MPI_Close_port((char*)port);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jport, port);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_accept(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jstring jport, jlong info, jint root)
-{
-    const char *port = jport == NULL ? NULL :
-                       (*env)->GetStringUTFChars(env, jport, NULL);
-    MPI_Comm newComm;
-
-    int rc = MPI_Comm_accept((char*)port, (MPI_Info)info,
-                             root, (MPI_Comm)comm, &newComm);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(jport != NULL)
-        (*env)->ReleaseStringUTFChars(env, jport, port);
-
-    return (jlong)newComm;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_connect(
-        JNIEnv *env, jobject jthis, jlong comm,
-        jstring jport, jlong info, jint root)
-{
-    const char *port = jport == NULL ? NULL :
-                       (*env)->GetStringUTFChars(env, jport, NULL);
-    MPI_Comm newComm;
-
-    int rc = MPI_Comm_connect((char*)port, (MPI_Info)info,
-                              root, (MPI_Comm)comm, &newComm);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(jport != NULL)
-        (*env)->ReleaseStringUTFChars(env, jport, port);
-
-    return (jlong)newComm;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Intracomm_publishName(
-        JNIEnv *env, jclass clazz, jstring jservice, jlong info, jstring jport)
-{
-    const char *service = (*env)->GetStringUTFChars(env, jservice, NULL),
-               *port    = (*env)->GetStringUTFChars(env, jport,    NULL);
-
-    int rc = MPI_Publish_name((char*)service, (MPI_Info)info, (char*)port);
-    ompi_java_exceptionCheck(env, rc);
-
-    (*env)->ReleaseStringUTFChars(env, jservice, service);
-    (*env)->ReleaseStringUTFChars(env, jport,    port);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Intracomm_unpublishName(
-        JNIEnv *env, jclass clazz, jstring jservice, jlong info, jstring jport)
-{
-    const char *service = (*env)->GetStringUTFChars(env, jservice, NULL),
-               *port    = (*env)->GetStringUTFChars(env, jport,    NULL);
-
-    int rc = MPI_Unpublish_name((char*)service, (MPI_Info)info, (char*)port);
-    ompi_java_exceptionCheck(env, rc);
-
-    (*env)->ReleaseStringUTFChars(env, jservice, service);
-    (*env)->ReleaseStringUTFChars(env, jport,    port);
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_Intracomm_lookupName(
-        JNIEnv *env, jclass clazz, jstring jservice, jlong info)
-{
-    char port[MPI_MAX_PORT_NAME + 1];
-    const char *service = (*env)->GetStringUTFChars(env, jservice, NULL);
-
-    int rc = MPI_Lookup_name((char*)service, (MPI_Info)info, port);
-    (*env)->ReleaseStringUTFChars(env, jservice, service);
-
-    return ompi_java_exceptionCheck(env, rc)
-           ? NULL : (*env)->NewStringUTF(env, port);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_spawn(
-        JNIEnv *env, jobject jthis, jlong comm, jstring jCommand,
-        jobjectArray jArgv, jint maxprocs, jlong info, jint root,
-        jintArray errCodes)
-{
-    int i, rc;
-    MPI_Comm intercomm;
-    const char* command = (*env)->GetStringUTFChars(env, jCommand, NULL);
-
-    jint *jErrCodes;
-    int  *cErrCodes = MPI_ERRCODES_IGNORE;
-
-    if(errCodes != NULL)
-        ompi_java_getIntArray(env, errCodes, &jErrCodes, &cErrCodes);
-
-    char **argv = MPI_ARGV_NULL;
-
-    if(jArgv != NULL)
-    {
-        jsize argvLength = (*env)->GetArrayLength(env, jArgv);
-        argv = (char**)calloc(argvLength + 1, sizeof(char*));
-
-        for(i = 0; i < argvLength; i++)
-        {
-            jstring a = (*env)->GetObjectArrayElement(env, jArgv, i);
-            argv[i] = strdup((*env)->GetStringUTFChars(env, a, NULL));
-            (*env)->DeleteLocalRef(env, a);
-        }
-
-        argv[argvLength] = NULL;
-    }
-
-    rc = MPI_Comm_spawn((char*)command, argv, maxprocs, (MPI_Info)info,
-                        root, (MPI_Comm)comm, &intercomm, cErrCodes);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(jArgv != NULL)
-    {
-        jsize argvLength = (*env)->GetArrayLength(env, jArgv);
-
-        for(i = 0; i < argvLength; i++)
-        {
-            jstring a = (*env)->GetObjectArrayElement(env, jArgv, i);
-            (*env)->ReleaseStringUTFChars(env, a, argv[i]);
-            (*env)->DeleteLocalRef(env, a);
-        }
-
-        free(argv);
-    }
-
-    if(errCodes != NULL)
-        ompi_java_releaseIntArray(env, errCodes, jErrCodes, cErrCodes);
-
-    (*env)->ReleaseStringUTFChars(env, jCommand, command);
-    return (jlong)intercomm;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Intracomm_spawnMultiple(
-        JNIEnv *env, jobject jthis, jlong comm, jobjectArray jCommands,
-        jobjectArray jArgv, jintArray maxProcs, jlongArray info,
-        jint root, jintArray errCodes)
-{
-    int i, rc;
-    MPI_Comm intercomm;
-    jlong *jInfo = (*env)->GetLongArrayElements(env, info, NULL);
-
-    jint *jMaxProcs, *jErrCodes;
-    int  *cMaxProcs, *cErrCodes = MPI_ERRCODES_IGNORE;
-    ompi_java_getIntArray(env, maxProcs, &jMaxProcs, &cMaxProcs);
-
-    if(errCodes != NULL)
-        ompi_java_getIntArray(env, errCodes, &jErrCodes, &cErrCodes);
-
-    int commandsLength = (*env)->GetArrayLength(env, jCommands),
-        infoLength     = (*env)->GetArrayLength(env, info);
-
-    char **commands = calloc(commandsLength, sizeof(char*)),
-         ***argv    = MPI_ARGVS_NULL;
-    MPI_Info *cInfo = calloc(infoLength, sizeof(MPI_Info));
-
-    for(i = 0; i < infoLength; i++)
-        cInfo[i] = (MPI_Info)jInfo[i];
-
-    for(i = 0; i < commandsLength; i++)
-    {
-        jstring a = (*env)->GetObjectArrayElement(env, jCommands, i);
-        commands[i] = (char*)(*env)->GetStringUTFChars(env, a, NULL);
-        (*env)->DeleteLocalRef(env, a);
-    }
-
-    if(jArgv != NULL)
-    {
-        int argvLength = (*env)->GetArrayLength(env, jArgv);
-        argv = calloc(argvLength, sizeof(char**));
-
-        for(i = 0; i < argvLength; i++)
-        {
-            jobjectArray arr = (*env)->GetObjectArrayElement(env, jArgv, i);
-            int j, length = (*env)->GetArrayLength(env, arr);
-            argv[i] = calloc(length + 1, sizeof(char*));
-
-            for(j = 0; j < length; j++)
-            {
-                jstring a = (*env)->GetObjectArrayElement(env, arr, j);
-                argv[i][j] = (char*)(*env)->GetStringUTFChars(env, a, NULL);
-                (*env)->DeleteLocalRef(env, a);
-            }
-
-            argv[i][length] = NULL;
-            (*env)->DeleteLocalRef(env, arr);
-        }
-    }
-
-    rc = MPI_Comm_spawn_multiple(
-            commandsLength, commands, argv, cMaxProcs, cInfo,
-            root, (MPI_Comm)comm, &intercomm, cErrCodes);
-
-    ompi_java_exceptionCheck(env, rc);
-
-    if(jArgv != NULL)
-    {
-        int argvLength = (*env)->GetArrayLength(env, jArgv);
-
-        for(i = 0; i < argvLength; i++)
-        {
-            jobjectArray arr = (*env)->GetObjectArrayElement(env, jArgv, i);
-            int j, length = (*env)->GetArrayLength(env, arr);
-
-            for(j = 0; j < length; j++)
-            {
-                jstring a = (*env)->GetObjectArrayElement(env, arr, j);
-                (*env)->ReleaseStringUTFChars(env, a, argv[i][j]);
-                (*env)->DeleteLocalRef(env, a);
-            }
-
-            (*env)->DeleteLocalRef(env, arr);
-            free(argv[i]);
-        }
-
-        free(argv);
-    }
-
-    for(i = 0; i < commandsLength; i++)
-    {
-        jstring a = (*env)->GetObjectArrayElement(env, jCommands, i);
-        (*env)->ReleaseStringUTFChars(env, a, commands[i]);
-        (*env)->DeleteLocalRef(env, a);
-    }
-
-    if(errCodes != NULL)
-        ompi_java_releaseIntArray(env, errCodes, jErrCodes, cErrCodes);
-
-    free(cInfo);
-    free(commands);
-    (*env)->ReleaseLongArrayElements(env, info, jInfo, JNI_ABORT);
-    ompi_java_forgetIntArray(env, maxProcs, jMaxProcs, cMaxProcs);
-    return (jlong)intercomm;
-}
diff --git a/ompi/mpi/java/c/mpi_MPI.c b/ompi/mpi/java/c/mpi_MPI.c
deleted file mode 100644
index f596411c05d..00000000000
--- a/ompi/mpi/java/c/mpi_MPI.c
+++ /dev/null
@@ -1,1352 +0,0 @@
-/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015-2016 Los Alamos National Security, LLC.  All rights
- *                         reserved.
- * Copyright (c) 2015-2016 Cisco Systems, Inc.  All rights reserved.
- * Copyright (c) 2015      Intel, Inc. All rights reserved.
- * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2016-2017 IBM Corporation.  All rights reserved.
- * Copyright (c) 2019       FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_MPI.c
- * Headerfile   : mpi_MPI.h
- * Author       : SungHoon Ko, Xinying Li (contributions from MAEDA Atusi)
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.17 $
- * Updated      : $Date: 2003/01/17 01:50:37 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-#include "ompi_config.h"
-
-#include <stdio.h>
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#include <stdlib.h>
-#include <string.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-#ifdef HAVE_DLFCN_H
-#include <dlfcn.h>
-#endif
-#include <poll.h>
-#ifdef HAVE_LIBGEN_H
-#include <libgen.h>
-#endif
-
-#include "opal/util/output.h"
-#include "opal/datatype/opal_convertor.h"
-#include "opal/mca/base/mca_base_var.h"
-
-#include "mpi.h"
-#include "ompi/errhandler/errcode.h"
-#include "ompi/errhandler/errcode-internal.h"
-#include "ompi/datatype/ompi_datatype.h"
-#include "mpi_MPI.h"
-#include "mpiJava.h"
-
-ompi_java_globals_t ompi_java = {0};
-int ompi_mpi_java_eager = 65536;
-opal_free_list_t ompi_java_buffers = {{{0}}};
-
-static void bufferConstructor(ompi_java_buffer_t *item)
-{
-    item->buffer = malloc(ompi_mpi_java_eager);
-}
-
-static void bufferDestructor(ompi_java_buffer_t *item)
-{
-    free(item->buffer);
-}
-
-OBJ_CLASS_INSTANCE(ompi_java_buffer_t,
-                   opal_free_list_item_t,
-                   bufferConstructor,
-                   bufferDestructor);
-
-/*
- * Class:    mpi_MPI
- * Method:   loadGlobalLibraries
- *
- */
-jint JNI_OnLoad(JavaVM *vm, void *reserved)
-{
-    // Ensure that PSM signal hijacking is disabled *before* loading
-    // the library (see comment in the function for more detail).
-    opal_init_psm();
-
-    return JNI_VERSION_1_6;
-}
-
-static void initFreeList(void)
-{
-    OBJ_CONSTRUCT(&ompi_java_buffers, opal_free_list_t);
-
-    int r = opal_free_list_init(&ompi_java_buffers,
-                                sizeof(ompi_java_buffer_t),
-                                opal_cache_line_size,
-                                OBJ_CLASS(ompi_java_buffer_t),
-                                0, /* payload size */
-                                0, /* payload align */
-                                2, /* initial elements to alloc */
-                                -1, /* max elements */
-                                2, /* num elements per alloc */
-                                NULL, /* mpool */
-                                0, /* mpool reg flags */
-                                NULL, /* unused0 */
-                                NULL, /* item_init */
-                                NULL /* inem_init context */);
-    if(r != OPAL_SUCCESS)
-    {
-        fprintf(stderr, "Unable to initialize ompi_java_buffers.\n");
-        exit(1);
-    }
-}
-
-static jclass findClass(JNIEnv *env, const char *className)
-{
-    jclass c = (*env)->FindClass(env, className),
-           r = (*env)->NewGlobalRef(env, c);
-
-    (*env)->DeleteLocalRef(env, c);
-    return r;
-}
-
-static void findClasses(JNIEnv *env)
-{
-    ompi_java.CartParmsClass  = findClass(env, "mpi/CartParms");
-    ompi_java.ShiftParmsClass = findClass(env, "mpi/ShiftParms");
-    ompi_java.GraphParmsClass = findClass(env, "mpi/GraphParms");
-
-    ompi_java.DistGraphNeighborsClass = findClass(
-                                        env, "mpi/DistGraphNeighbors");
-
-    ompi_java.StatusClass    = findClass(env, "mpi/Status");
-    ompi_java.ExceptionClass = findClass(env, "mpi/MPIException");
-
-    ompi_java.ExceptionInit = (*env)->GetMethodID(
-                              env, ompi_java.ExceptionClass,
-                              "<init>", "(IILjava/lang/String;)V");
-
-    ompi_java.IntegerClass = findClass(env, "java/lang/Integer");
-    ompi_java.LongClass    = findClass(env, "java/lang/Long");
-
-    ompi_java.IntegerValueOf = (*env)->GetStaticMethodID(
-            env, ompi_java.IntegerClass, "valueOf", "(I)Ljava/lang/Integer;");
-    ompi_java.LongValueOf = (*env)->GetStaticMethodID(
-            env, ompi_java.LongClass, "valueOf", "(J)Ljava/lang/Long;");
-}
-
-static void deleteClasses(JNIEnv *env)
-{
-    (*env)->DeleteGlobalRef(env, ompi_java.CartParmsClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.ShiftParmsClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.VersionClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.CountClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.GraphParmsClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.DistGraphNeighborsClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.StatusClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.ExceptionClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.IntegerClass);
-    (*env)->DeleteGlobalRef(env, ompi_java.LongClass);
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_MPI_newInt2(JNIEnv *env, jclass clazz)
-{
-    struct { int a; int b; } s;
-    int iOff = (int)((MPI_Aint)(&(s.b)) - (MPI_Aint)(&(s.a)));
-    jclass c = (*env)->FindClass(env, "mpi/Int2");
-    jmethodID m = (*env)->GetMethodID(env, c, "<init>", "(II)V");
-    return (*env)->NewObject(env, c, m, iOff, sizeof(int));
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_MPI_newShortInt(JNIEnv *env, jclass clazz)
-{
-    struct { short a; int b; } s;
-    int iOff = (int)((MPI_Aint)(&(s.b)) - (MPI_Aint)(&(s.a)));
-    jclass c = (*env)->FindClass(env, "mpi/ShortInt");
-    jmethodID m = (*env)->GetMethodID(env, c, "<init>", "(III)V");
-    return (*env)->NewObject(env, c, m, sizeof(short), iOff, sizeof(int));
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_MPI_newLongInt(JNIEnv *env, jclass clazz)
-{
-    struct { long a; int b; } s;
-    int iOff = (int)((MPI_Aint)(&(s.b)) - (MPI_Aint)(&(s.a)));
-    jclass c = (*env)->FindClass(env, "mpi/LongInt");
-    jmethodID m = (*env)->GetMethodID(env, c, "<init>", "(III)V");
-    return (*env)->NewObject(env, c, m, sizeof(long), iOff, sizeof(int));
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_MPI_newFloatInt(JNIEnv *env, jclass clazz)
-{
-    struct { float a; int b; } s;
-    int iOff = (int)((MPI_Aint)(&(s.b)) - (MPI_Aint)(&(s.a)));
-    jclass c = (*env)->FindClass(env, "mpi/FloatInt");
-    jmethodID m = (*env)->GetMethodID(env, c, "<init>", "(II)V");
-    return (*env)->NewObject(env, c, m, iOff, sizeof(int));
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_MPI_newDoubleInt(JNIEnv *env, jclass clazz)
-{
-    struct { double a; int b; } s;
-    int iOff = (int)((MPI_Aint)(&(s.b)) - (MPI_Aint)(&(s.a)));
-    jclass c = (*env)->FindClass(env, "mpi/DoubleInt");
-    jmethodID m = (*env)->GetMethodID(env, c, "<init>", "(II)V");
-    return (*env)->NewObject(env, c, m, iOff, sizeof(int));
-}
-
-JNIEXPORT void JNICALL Java_mpi_MPI_initVersion(JNIEnv *env, jclass jthis)
-{
-    ompi_java.VersionClass = findClass(env, "mpi/Version");
-    ompi_java.VersionInit = (*env)->GetMethodID(env, ompi_java.VersionClass, "<init>", "(II)V");
-}
-
-JNIEXPORT jobjectArray JNICALL Java_mpi_MPI_Init_1jni(
-        JNIEnv *env, jclass clazz, jobjectArray argv)
-{
-    jsize i;
-    jclass string;
-    jobject value;
-
-    int len = (*env)->GetArrayLength(env, argv);
-    char **sargs = (char**)calloc(len+1, sizeof(char*));
-
-    for(i = 0; i < len; i++)
-    {
-        jstring jc = (jstring)(*env)->GetObjectArrayElement(env, argv, i);
-        const char *s = (*env)->GetStringUTFChars(env, jc, NULL);
-        sargs[i] = strdup(s);
-        (*env)->ReleaseStringUTFChars(env, jc, s);
-        (*env)->DeleteLocalRef(env, jc);
-    }
-
-    int rc = MPI_Init(&len, &sargs);
-    
-    if(ompi_java_exceptionCheck(env, rc)) {
-        for(i = 0; i < len; i++)
-            free (sargs[i]);
-        free(sargs);
-        return NULL;
-    }
-
-    mca_base_var_register("ompi", "mpi", "java", "eager",
-                          "Java buffers eager size",
-                          MCA_BASE_VAR_TYPE_INT, NULL, 0, 0,
-                          OPAL_INFO_LVL_5,
-                          MCA_BASE_VAR_SCOPE_READONLY,
-                          &ompi_mpi_java_eager);
-
-    string = (*env)->FindClass(env, "java/lang/String");
-    value = (*env)->NewObjectArray(env, len, string, NULL);
-
-    for(i = 0; i < len; i++)
-    {
-        jstring jc = (*env)->NewStringUTF(env, sargs[i]);
-        (*env)->SetObjectArrayElement(env, value, i, jc);
-        (*env)->DeleteLocalRef(env, jc);
-        free (sargs[i]);
-    }
-
-    free (sargs);
-
-    findClasses(env);
-    initFreeList();
-    return value;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_MPI_InitThread_1jni(
-        JNIEnv *env, jclass clazz, jobjectArray argv, jint required)
-{
-    jsize i;
-    int len = (*env)->GetArrayLength(env,argv);
-    char **sargs = (char**)calloc(len+1, sizeof(char*));
-
-    for(i = 0; i < len; i++)
-    {
-        jstring jc = (jstring)(*env)->GetObjectArrayElement(env, argv, i);
-        const char *s = (*env)->GetStringUTFChars(env, jc, 0);
-        sargs[i] = strdup(s);
-        (*env)->ReleaseStringUTFChars(env, jc, s);
-        (*env)->DeleteLocalRef(env, jc);
-    }
-
-    int provided;
-    int rc = MPI_Init_thread(&len, &sargs, required, &provided);
-    
-    if(ompi_java_exceptionCheck(env, rc)) {
-        for(i = 0; i < len; i++)
-            free (sargs[i]);
-        free(sargs);
-        return -1;
-    }
-
-    findClasses(env);
-    initFreeList();
-    return provided;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_MPI_queryThread_1jni(JNIEnv *env, jclass clazz)
-{
-    int provided;
-    int rc = MPI_Query_thread(&provided);
-    ompi_java_exceptionCheck(env, rc);
-    return provided;
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_MPI_isThreadMain_1jni(
-                           JNIEnv *env, jclass clazz)
-{
-    int flag;
-    int rc = MPI_Is_thread_main(&flag);
-    ompi_java_exceptionCheck(env, rc);
-    return flag ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT void JNICALL Java_mpi_MPI_Finalize_1jni(JNIEnv *env, jclass obj)
-{
-    OBJ_DESTRUCT(&ompi_java_buffers);
-    int rc = MPI_Finalize();
-    ompi_java_exceptionCheck(env, rc);
-    deleteClasses(env);
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_MPI_getVersionJNI(JNIEnv *env, jclass jthis)
-{
-	int version, subversion;
-	int rc = MPI_Get_version(&version, &subversion);
-	ompi_java_exceptionCheck(env, rc);
-
-	return (*env)->NewObject(env, ompi_java.VersionClass,
-	                             ompi_java.VersionInit, version, subversion);
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_MPI_getLibVersionJNI(JNIEnv *env, jclass jthis)
-{
-	int length;
-	char version[MPI_MAX_LIBRARY_VERSION_STRING];
-	int rc = MPI_Get_library_version(version, &length);
-	ompi_java_exceptionCheck(env, rc);
-
-	return (*env)->NewStringUTF(env, version);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_MPI_getProcessorName(
-                       JNIEnv *env, jclass obj, jbyteArray buf)
-{
-    int len;
-    jbyte* bufc = (jbyte*)((*env)->GetByteArrayElements(env, buf, NULL));
-    int rc = MPI_Get_processor_name((char*)bufc, &len);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseByteArrayElements(env, buf, bufc, 0);
-    return len;
-}
-
-JNIEXPORT jdouble JNICALL Java_mpi_MPI_wtime_1jni(JNIEnv *env, jclass jthis)
-{
-    return MPI_Wtime();
-}
-
-JNIEXPORT jdouble JNICALL Java_mpi_MPI_wtick_1jni(JNIEnv *env, jclass jthis)
-{
-    return MPI_Wtick();
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_MPI_isInitialized(JNIEnv *env, jclass jthis)
-{
-    int flag;
-    int rc = MPI_Initialized(&flag);
-    ompi_java_exceptionCheck(env, rc);
-    return flag ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_MPI_isFinalized(JNIEnv *env, jclass jthis)
-{
-    int flag;
-    int rc = MPI_Finalized(&flag);
-    ompi_java_exceptionCheck(env, rc);
-    return flag ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT void JNICALL Java_mpi_MPI_attachBuffer_1jni(
-                       JNIEnv *env, jclass jthis, jbyteArray buf)
-{
-    int size=(*env)->GetArrayLength(env,buf);
-    jbyte* bufptr = (*env)->GetByteArrayElements(env, buf, NULL);
-    int rc = MPI_Buffer_attach(bufptr,size);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_MPI_detachBuffer_1jni(
-                       JNIEnv *env, jclass jthis, jbyteArray buf)
-{
-    int size;
-    jbyte* bufptr;
-    int rc = MPI_Buffer_detach(&bufptr, &size);
-    ompi_java_exceptionCheck(env, rc);
-
-    if(buf != NULL)
-        (*env)->ReleaseByteArrayElements(env,buf,bufptr,0);
-}
-
-void* ompi_java_getArrayCritical(void** bufBase, JNIEnv *env,
-                                 jobject buf, int offset)
-{
-    *bufBase = (jbyte*)(*env)->GetPrimitiveArrayCritical(env, buf, NULL);
-    return ((jbyte*)*bufBase) + offset;
-}
-
-void* ompi_java_getDirectBufferAddress(JNIEnv *env, jobject buf)
-{
-    /* Allow NULL buffers to send/recv 0 items as control messages. */
-    return buf == NULL ? NULL : (*env)->GetDirectBufferAddress(env, buf);
-}
-
-static int getTypeExtent(JNIEnv *env, MPI_Datatype type)
-{
-    MPI_Aint lb, extent;
-    int rc = MPI_Type_get_extent(type, &lb, &extent);
-    ompi_java_exceptionCheck(env, rc);
-    int value = extent;
-    assert(((MPI_Aint)value) == extent);
-    return value;
-}
-
-static void getArrayRegion(JNIEnv *env, jobject buf, int baseType,
-                           int offset, int length, void *ptr)
-{
-    switch(baseType)
-    {
-        case 0:
-            break;
-        case 1:
-            (*env)->GetByteArrayRegion(env, buf, offset, length, ptr);
-            break;
-        case 2:
-            (*env)->GetCharArrayRegion(env, buf, offset / 2, length / 2, ptr);
-            break;
-        case 3:
-            (*env)->GetShortArrayRegion(env, buf, offset / 2, length / 2, ptr);
-            break;
-        case 4:
-            (*env)->GetBooleanArrayRegion(env, buf, offset, length, ptr);
-            break;
-        case 5:
-            (*env)->GetIntArrayRegion(env, buf, offset / 4, length / 4, ptr);
-            break;
-        case 6:
-            (*env)->GetLongArrayRegion(env, buf, offset / 8, length / 8, ptr);
-            break;
-        case 7:
-            (*env)->GetFloatArrayRegion(env, buf, offset / 4, length / 4, ptr);
-            break;
-        case 8:
-            (*env)->GetDoubleArrayRegion(env, buf, offset / 8, length / 8, ptr);
-            break;
-        case 9:
-            (*env)->GetByteArrayRegion(env, buf, offset, length, ptr);
-            break;
-        default:
-            assert(0);
-    }
-}
-
-static void setArrayRegion(JNIEnv *env, jobject buf, int baseType,
-                           int offset, int length, void *ptr)
-{
-    switch(baseType)
-    {
-        case 0:
-            break;
-        case 1:
-            (*env)->SetByteArrayRegion(env, buf, offset, length, ptr);
-            break;
-        case 2:
-            (*env)->SetCharArrayRegion(env, buf, offset / 2, length / 2, ptr);
-            break;
-        case 3:
-            (*env)->SetShortArrayRegion(env, buf, offset / 2, length / 2, ptr);
-            break;
-        case 4:
-            (*env)->SetBooleanArrayRegion(env, buf, offset, length, ptr);
-            break;
-        case 5:
-            (*env)->SetIntArrayRegion(env, buf, offset / 4, length / 4, ptr);
-            break;
-        case 6:
-            (*env)->SetLongArrayRegion(env, buf, offset / 8, length / 8, ptr);
-            break;
-        case 7:
-            (*env)->SetFloatArrayRegion(env, buf, offset / 4, length / 4, ptr);
-            break;
-        case 8:
-            (*env)->SetDoubleArrayRegion(env, buf, offset / 8, length / 8, ptr);
-            break;
-        case 9:
-            (*env)->SetByteArrayRegion(env, buf, offset, length, ptr);
-            break;
-        default:
-            assert(0);
-    }
-}
-
-static void* getBuffer(JNIEnv *env, ompi_java_buffer_t **item, int size)
-{
-    if(size > ompi_mpi_java_eager)
-    {
-        *item = NULL;
-        return malloc(size);
-    }
-    else
-    {
-        opal_free_list_item_t *freeListItem;
-        freeListItem = opal_free_list_get (&ompi_java_buffers);
-
-        ompi_java_exceptionCheck(env, NULL == freeListItem ? MPI_ERR_NO_MEM :
-                                 MPI_SUCCESS);
-        if (NULL == freeListItem) {
-            return NULL;
-        }
-
-        *item = (ompi_java_buffer_t*)freeListItem;
-        return (*item)->buffer;
-    }
-}
-
-static void releaseBuffer(void *ptr, ompi_java_buffer_t *item)
-{
-    if(item == NULL)
-    {
-        free(ptr);
-    }
-    else
-    {
-        assert(item->buffer == ptr);
-        opal_free_list_return (&ompi_java_buffers, (opal_free_list_item_t*)item);
-    }
-}
-
-static int getCountv(int *counts, int *displs, int size)
-{
-    /* Maybe displs is not ordered. */
-    int i, max = 0;
-
-    for(i = 1; i < size; i++)
-    {
-        if(displs[max] < displs[i])
-            max = i;
-    }
-
-    return displs[max] * counts[max];
-}
-
-static void* getReadPtr(ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-                        int offset, int count, MPI_Datatype type, int baseType)
-{
-    int  length = count * getTypeExtent(env, type);
-    void *ptr   = getBuffer(env, item, length);
-
-    if(opal_datatype_is_contiguous_memory_layout(&type->super, count))
-    {
-        getArrayRegion(env, buf, baseType, offset, length, ptr);
-    }
-    else
-    {
-        void *inBuf, *inBase;
-        inBuf = ompi_java_getArrayCritical(&inBase, env, buf, offset);
-
-        int rc = opal_datatype_copy_content_same_ddt(
-                 &type->super, count, ptr, inBuf);
-
-        ompi_java_exceptionCheck(env,
-                rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, inBase, JNI_ABORT);
-    }
-
-    return ptr;
-}
-
-static void* getReadPtrRank(
-        ompi_java_buffer_t **item, JNIEnv *env, jobject buf, int offset,
-        int count, int size, int rank, MPI_Datatype type, int baseType)
-{
-    int  extent = getTypeExtent(env, type),
-         rLen   = extent * count,
-         length = rLen * size,
-         rDispl = rLen * rank,
-         rOff   = offset + rDispl;
-    void *ptr   = getBuffer(env, item, length);
-    void *rPtr  = (char*)ptr + rDispl;
-
-    if(opal_datatype_is_contiguous_memory_layout(&type->super, count))
-    {
-        getArrayRegion(env, buf, baseType, rOff, rLen, rPtr);
-    }
-    else
-    {
-        void *bufPtr, *bufBase;
-        bufPtr = ompi_java_getArrayCritical(&bufBase, env, buf, rOff);
-
-        int rc = opal_datatype_copy_content_same_ddt(
-                 &type->super, count, rPtr, bufPtr);
-
-        ompi_java_exceptionCheck(env,
-                rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, JNI_ABORT);
-    }
-
-    return ptr;
-}
-
-static void* getReadPtrvRank(
-        ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        int offset, int *counts, int *displs, int size,
-        int rank, MPI_Datatype type, int baseType)
-{
-    int  extent  = getTypeExtent(env, type),
-         length  = extent * getCountv(counts, displs, size);
-    void *ptr    = getBuffer(env, item, length);
-    int  rootOff = offset + extent * displs[rank];
-
-    if(opal_datatype_is_contiguous_memory_layout(&type->super, counts[rank]))
-    {
-        int  rootLength = extent * counts[rank];
-        void *rootPtr   = (char*)ptr + extent * displs[rank];
-        getArrayRegion(env, buf, baseType, rootOff, rootLength, rootPtr);
-    }
-    else
-    {
-        void *inBuf, *inBase;
-        inBuf = ompi_java_getArrayCritical(&inBase, env, buf, rootOff);
-
-        int rc = opal_datatype_copy_content_same_ddt(
-                 &type->super, counts[rank], ptr, inBuf);
-
-        ompi_java_exceptionCheck(env,
-                rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, inBase, JNI_ABORT);
-    }
-
-    return ptr;
-}
-
-static void* getReadPtrwRank(
-        ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        int *offsets, int *counts, int *displs, int size,
-        int rank, MPI_Datatype *types, int *baseTypes)
-{
-    int  extent  = getTypeExtent(env, types[rank]),
-         length  = getCountv(counts, displs, size);
-    void *ptr    = getBuffer(env, item, length);
-    int  rootOff = offsets[rank] + displs[rank];
-
-    if(opal_datatype_is_contiguous_memory_layout(&types[rank]->super, counts[rank]))
-    {
-        int  rootLength = extent * counts[rank];
-        void *rootPtr   = (char*)ptr + displs[rank];
-        getArrayRegion(env, buf, baseTypes[rank], rootOff, rootLength, rootPtr);
-    }
-    else
-    {
-        void *inBuf, *inBase;
-        inBuf = ompi_java_getArrayCritical(&inBase, env, buf, rootOff);
-
-        int rc = opal_datatype_copy_content_same_ddt(
-                 &types[rank]->super, counts[rank], ptr, inBuf);
-
-        ompi_java_exceptionCheck(env,
-                rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, inBase, JNI_ABORT);
-    }
-
-    return ptr;
-}
-
-static void* getReadPtrvAll(
-        ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        int offset, int *counts, int *displs, int size,
-        MPI_Datatype type, int baseType)
-{
-    int  i,
-         extent  = getTypeExtent(env, type),
-         length  = extent * getCountv(counts, displs, size);
-    void *ptr    = getBuffer(env, item, length);
-
-    if(opal_datatype_is_contiguous_memory_layout(&type->super, 2))
-    {
-        for(i = 0; i < size; i++)
-        {
-            int   iOff = offset + extent * displs[i],
-                  iLen = extent * counts[i];
-            void *iPtr = (char*)ptr + extent * displs[i];
-            getArrayRegion(env, buf, baseType, iOff, iLen, iPtr);
-        }
-    }
-    else
-    {
-        void *bufPtr, *bufBase;
-        bufPtr = ompi_java_getArrayCritical(&bufBase, env, buf, offset);
-
-        for(i = 0; i < size; i++)
-        {
-            int   iOff = extent * displs[i];
-            char *iBuf = iOff + (char*)bufPtr,
-                 *iPtr = iOff + (char*)ptr;
-
-            int rc = opal_datatype_copy_content_same_ddt(
-                     &type->super, counts[i], iPtr, iBuf);
-
-            ompi_java_exceptionCheck(env,
-                    rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-        }
-
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, JNI_ABORT);
-    }
-
-    return ptr;
-}
-
-static void* getReadPtrwAll(
-        ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        int *offsets, int *counts, int *displs, int size,
-        MPI_Datatype *types, int *baseTypes)
-{
-
-    int length  = getCountv(counts, displs, size);
-    void *ptr    = getBuffer(env, item, length);
-
-    for(int i = 0; i < size; i++)
-    {
-        int extent  = getTypeExtent(env, types[i]);
-
-        if(opal_datatype_is_contiguous_memory_layout(&types[i]->super, 2))
-        {
-            int   iOff = offsets[i] + displs[i],
-                  iLen = extent * counts[i];
-            void *iPtr = (char*)ptr + displs[i];
-            getArrayRegion(env, buf, baseTypes[i], iOff, iLen, iPtr);
-        }
-        else
-        {
-            void *bufPtr, *bufBase;
-            bufPtr = ompi_java_getArrayCritical(&bufBase, env, buf, offsets[i]);
-
-            int   iOff = displs[i];
-            char *iBuf = iOff + (char*)bufPtr,
-                 *iPtr = iOff + (char*)ptr;
-
-            int rc = opal_datatype_copy_content_same_ddt(
-                     &types[i]->super, counts[i], iPtr, iBuf);
-
-            ompi_java_exceptionCheck(env,
-                    rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-
-            (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, JNI_ABORT);
-        }
-
-    }
-
-    return ptr;
-}
-
-static void* getWritePtr(ompi_java_buffer_t **item, JNIEnv *env,
-                         int count, MPI_Datatype type)
-{
-    int extent = getTypeExtent(env, type),
-        length = count * extent;
-
-    return getBuffer(env, item, length);
-}
-
-static void* getWritePtrv(ompi_java_buffer_t **item, JNIEnv *env,
-                          int *counts, int *displs, int size, MPI_Datatype type)
-{
-    int extent = getTypeExtent(env, type),
-        count  = getCountv(counts, displs, size),
-        length = extent * count;
-
-    return getBuffer(env, item, length);
-}
-
-static void* getWritePtrw(ompi_java_buffer_t **item, JNIEnv *env,
-                          int *counts, int *displs, int size, MPI_Datatype *types)
-{
-    int length = getCountv(counts, displs, size);
-
-    return getBuffer(env, item, length);
-}
-
-void ompi_java_getReadPtr(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        jboolean db, int offset, int count, MPI_Datatype type, int baseType)
-{
-    if(buf == NULL || baseType == 0)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *ptr  = NULL;
-        *item = NULL;
-    }
-    else if(db)
-    {
-        assert(offset == 0);
-        *ptr  = (*env)->GetDirectBufferAddress(env, buf);
-        *item = NULL;
-    }
-    else
-    {
-        *ptr = getReadPtr(item, env, buf, offset, count, type, baseType);
-    }
-}
-
-void ompi_java_getReadPtrRank(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int offset, int count, int size,
-        int rank, MPI_Datatype type, int baseType)
-{
-    if(buf == NULL || baseType == 0)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *ptr  = NULL;
-        *item = NULL;
-    }
-    else if(db)
-    {
-        assert(offset == 0);
-        *ptr  = (*env)->GetDirectBufferAddress(env, buf);
-        *item = NULL;
-    }
-    else
-    {
-        *ptr = getReadPtrRank(item, env, buf, offset, count,
-                              size, rank, type, baseType);
-    }
-}
-
-void ompi_java_getReadPtrv(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int offset, int *counts, int *displs,
-        int size, int rank, MPI_Datatype type, int baseType)
-{
-    if(buf == NULL)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *ptr  = NULL;
-        *item = NULL;
-    }
-    else if(db)
-    {
-        assert(offset == 0);
-        *ptr  = (*env)->GetDirectBufferAddress(env, buf);
-        *item = NULL;
-    }
-    else if(rank == -1)
-    {
-        *ptr = getReadPtrvAll(item, env, buf, offset, counts,
-                              displs, size, type, baseType);
-    }
-    else
-    {
-        *ptr = getReadPtrvRank(item, env, buf, offset, counts,
-                               displs, size, rank, type, baseType);
-    }
-}
-
-void ompi_java_getReadPtrw(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int *offsets, int *counts, int *displs,
-        int size, int rank, MPI_Datatype *types, int *baseTypes)
-{
-    int i;
-
-    if(buf == NULL)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *ptr  = NULL;
-        *item = NULL;
-    }
-    else if(db)
-    {
-        for(i = 0; i < size; i++){
-            assert(offsets[i] == 0);
-        }
-        *ptr  = (*env)->GetDirectBufferAddress(env, buf);
-        *item = NULL;
-    }
-    else if(rank == -1)
-    {
-        *ptr = getReadPtrwAll(item, env, buf, offsets, counts,
-                              displs, size, types, baseTypes);
-    }
-    else
-    {
-        *ptr = getReadPtrwRank(item, env, buf, offsets, counts,
-                               displs, size, rank, types, baseTypes);
-    }
-}
-
-void ompi_java_releaseReadPtr(
-        void *ptr, ompi_java_buffer_t *item, jobject buf, jboolean db)
-{
-    if(!db && buf && ptr)
-        releaseBuffer(ptr, item);
-}
-
-void ompi_java_getWritePtr(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env,
-        jobject buf, jboolean db, int count, MPI_Datatype type)
-{
-    if(buf == NULL)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *ptr  = NULL;
-        *item = NULL;
-    }
-    else if(db)
-    {
-        *ptr  = (*env)->GetDirectBufferAddress(env, buf);
-        *item = NULL;
-    }
-    else
-    {
-        *ptr = getWritePtr(item, env, count, type);
-    }
-}
-
-void ompi_java_getWritePtrv(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        jboolean db, int *counts, int *displs, int size, MPI_Datatype type)
-{
-    if(buf == NULL)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *ptr  = NULL;
-        *item = NULL;
-    }
-    else if(db)
-    {
-        *ptr  = (*env)->GetDirectBufferAddress(env, buf);
-        *item = NULL;
-    }
-    else
-    {
-        *ptr = getWritePtrv(item, env, counts, displs, size, type);
-    }
-}
-
-void ompi_java_getWritePtrw(
-        void **ptr, ompi_java_buffer_t **item, JNIEnv *env, jobject buf,
-        jboolean db, int *counts, int *displs, int size, MPI_Datatype *types)
-{
-    if(buf == NULL)
-    {
-        /* Allow NULL buffers to send/recv 0 items as control messages. */
-        *ptr  = NULL;
-        *item = NULL;
-    }
-    else if(db)
-    {
-        *ptr  = (*env)->GetDirectBufferAddress(env, buf);
-        *item = NULL;
-    }
-    else
-    {
-        *ptr = getWritePtrw(item, env, counts, displs, size, types);
-    }
-}
-
-void ompi_java_releaseWritePtr(
-        void *ptr, ompi_java_buffer_t *item, JNIEnv *env, jobject buf,
-        jboolean db, int offset, int count, MPI_Datatype type, int baseType)
-{
-    if(db || !buf || !ptr)
-        return;
-
-    if(opal_datatype_is_contiguous_memory_layout(&type->super, count))
-    {
-        int length = count * getTypeExtent(env, type);
-        setArrayRegion(env, buf, baseType, offset, length, ptr);
-    }
-    else
-    {
-        void *inBuf, *inBase;
-        inBuf = ompi_java_getArrayCritical(&inBase, env, buf, offset);
-
-        int rc = opal_datatype_copy_content_same_ddt(
-                 &type->super, count, inBuf, ptr);
-
-        ompi_java_exceptionCheck(env,
-                rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, inBase, 0);
-    }
-
-    releaseBuffer(ptr, item);
-}
-
-void ompi_java_releaseWritePtrv(
-        void *ptr, ompi_java_buffer_t *item, JNIEnv *env,
-        jobject buf, jboolean db, int offset, int *counts, int *displs,
-        int size, MPI_Datatype type, int baseType)
-{
-    if(db || !buf || !ptr)
-        return;
-
-    int i;
-    int extent = getTypeExtent(env, type);
-
-    if(opal_datatype_is_contiguous_memory_layout(&type->super, 2))
-    {
-        for(i = 0; i < size; i++)
-        {
-            int   iOff = offset + extent * displs[i],
-                  iLen = extent * counts[i];
-            void *iPtr = (char*)ptr + extent * displs[i];
-            setArrayRegion(env, buf, baseType, iOff, iLen, iPtr);
-        }
-    }
-    else
-    {
-        void *bufPtr, *bufBase;
-        bufPtr = ompi_java_getArrayCritical(&bufBase, env, buf, offset);
-
-        for(i = 0; i < size; i++)
-        {
-            int   iOff = extent * displs[i];
-            char *iBuf = iOff + (char*)bufPtr,
-                 *iPtr = iOff + (char*)ptr;
-
-            int rc = opal_datatype_copy_content_same_ddt(
-                     &type->super, counts[i], iBuf, iPtr);
-
-            ompi_java_exceptionCheck(env,
-                    rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-        }
-
-        (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, 0);
-    }
-
-    releaseBuffer(ptr, item);
-}
-
-void ompi_java_releaseWritePtrw(
-        void *ptr, ompi_java_buffer_t *item, JNIEnv *env,
-        jobject buf, jboolean db, int *offsets, int *counts, int *displs,
-        int size, MPI_Datatype *types, int *baseTypes)
-{
-    if(db || !buf || !ptr)
-        return;
-
-    int i;
-
-    for(i = 0; i < size; i++)
-    {
-        int extent = getTypeExtent(env, types[i]);
-
-        if(opal_datatype_is_contiguous_memory_layout(&types[i]->super, 2))
-        {
-            int   iOff = offsets[i] + displs[i],
-                  iLen = extent * counts[i];
-            void *iPtr = (char*)ptr + displs[i];
-            setArrayRegion(env, buf, baseTypes[i], iOff, iLen, iPtr);
-        }
-        else
-        {
-            void *bufPtr, *bufBase;
-
-            bufPtr = ompi_java_getArrayCritical(&bufBase, env, buf, offsets[i]);
-            int   iOff = displs[i];
-            char *iBuf = iOff + (char*)bufPtr,
-                 *iPtr = iOff + (char*)ptr;
-
-            int rc = opal_datatype_copy_content_same_ddt(
-                     &types[i]->super, counts[i], iBuf, iPtr);
-
-            ompi_java_exceptionCheck(env,
-                    rc==OPAL_SUCCESS ? OMPI_SUCCESS : OMPI_ERROR);
-
-            (*env)->ReleasePrimitiveArrayCritical(env, buf, bufBase, 0);
-        }
-
-    }
-    releaseBuffer(ptr, item);
-}
-
-jobject ompi_java_Integer_valueOf(JNIEnv *env, jint i)
-{
-    return (*env)->CallStaticObjectMethod(env,
-           ompi_java.IntegerClass, ompi_java.IntegerValueOf, i);
-}
-
-jobject ompi_java_Long_valueOf(JNIEnv *env, jlong i)
-{
-    return (*env)->CallStaticObjectMethod(env,
-           ompi_java.LongClass, ompi_java.LongValueOf, i);
-}
-
-void ompi_java_getIntArray(JNIEnv *env, jintArray array,
-                           jint **jptr, int **cptr)
-{
-    jint *jInts = (*env)->GetIntArrayElements(env, array, NULL);
-    *jptr = jInts;
-
-    if(sizeof(int) == sizeof(jint))
-    {
-        *cptr = (int*)jInts;
-    }
-    else
-    {
-        int i, length = (*env)->GetArrayLength(env, array);
-        int *cInts = calloc(length, sizeof(int));
-
-        for(i = 0; i < length; i++)
-            cInts[i] = jInts[i];
-
-        *cptr = cInts;
-    }
-}
-
-void ompi_java_releaseIntArray(JNIEnv *env, jintArray array,
-                               jint *jptr, int *cptr)
-{
-    if(jptr != cptr)
-    {
-        int i, length = (*env)->GetArrayLength(env, array);
-
-        for(i = 0; i < length; i++)
-            jptr[i] = cptr[i];
-
-        free(cptr);
-    }
-
-    (*env)->ReleaseIntArrayElements(env, array, jptr, 0);
-}
-
-void ompi_java_forgetIntArray(JNIEnv *env, jintArray array,
-                              jint *jptr, int *cptr)
-{
-    if(jptr != cptr)
-        free(cptr);
-
-    (*env)->ReleaseIntArrayElements(env, array, jptr, JNI_ABORT);
-}
-
-void ompi_java_getDatatypeArray(JNIEnv *env, jlongArray array,
-                           jlong **jptr, MPI_Datatype **cptr)
-{
-    jlong *jLongs = (*env)->GetLongArrayElements(env, array, NULL);
-    *jptr = jLongs;
-
-    int i, length = (*env)->GetArrayLength(env, array);
-    MPI_Datatype *cDatatypes = calloc(length, sizeof(MPI_Datatype));
-
-    for(i = 0; i < length; i++){
-        cDatatypes[i] = (MPI_Datatype)jLongs[i];
-    }
-    *cptr = cDatatypes;
-}
-
-void ompi_java_forgetDatatypeArray(JNIEnv *env, jlongArray array,
-                              jlong *jptr, MPI_Datatype *cptr)
-{
-    if((long)jptr != (long)cptr)
-        free(cptr);
-
-    (*env)->ReleaseLongArrayElements(env, array, jptr, JNI_ABORT);
-}
-
-void ompi_java_getBooleanArray(JNIEnv *env, jbooleanArray array,
-                               jboolean **jptr, int **cptr)
-{
-    int i, length = (*env)->GetArrayLength(env, array);
-    jboolean *jb = (*env)->GetBooleanArrayElements(env, array, NULL);
-    int *cb = (int*)calloc(length, sizeof(int));
-
-    for(i = 0; i < length; i++)
-        cb[i] = jb[i];
-
-    *jptr = jb;
-    *cptr = cb;
-}
-
-void ompi_java_releaseBooleanArray(JNIEnv *env, jbooleanArray array,
-                                   jboolean *jptr, int *cptr)
-{
-    int i, length = (*env)->GetArrayLength(env, array);
-
-    for(i = 0; i < length; i++)
-        jptr[i] = cptr[i] ? JNI_TRUE : JNI_FALSE;
-
-    free(cptr);
-    (*env)->ReleaseBooleanArrayElements(env, array, jptr, 0);
-}
-
-void ompi_java_forgetBooleanArray(JNIEnv *env, jbooleanArray array,
-                                  jboolean *jptr, int *cptr)
-{
-    free(cptr);
-    (*env)->ReleaseBooleanArrayElements(env, array, jptr, JNI_ABORT);
-}
-
-void ompi_java_getPtrArray(JNIEnv *env, jlongArray array,
-                           jlong **jptr, void ***cptr)
-{
-    jlong *jp = *jptr = (*env)->GetLongArrayElements(env, array, NULL);
-
-    if(sizeof(jlong) == sizeof(void*))
-    {
-        *cptr = (void**)jp;
-    }
-    else
-    {
-        int i, length = (*env)->GetArrayLength(env, array);
-        void **cp = *cptr = calloc(length, sizeof(void*));
-
-        for(i = 0; i < length; i++)
-            cp[i] = (void*)jp[i];
-    }
-}
-
-void ompi_java_releasePtrArray(JNIEnv *env, jlongArray array,
-                               jlong *jptr, void **cptr)
-{
-    if(jptr != (jlong*)cptr)
-    {
-        int i, length = (*env)->GetArrayLength(env, array);
-
-        for(i = 0; i < length; i++)
-            jptr[i] = (jlong)cptr[i];
-
-        free(cptr);
-    }
-
-    (*env)->ReleaseLongArrayElements(env, array, jptr, 0);
-}
-
-/* This method checks whether an MPI or JNI exception has occurred.
- * If an exception occurs, the C code will continue running.  Once
- * code execution returns to Java code, an exception is immediately
- * thrown.  Since an exception has occurred somewhere in the C code,
- * the object that is returned from C may not be valid.  This is not
- * an issue, however, as the assignment operation will not be
- * executed.  The results of this method need not be checked if the
- * only following code cleans up memory and then returns to Java.
- * If existing objects are changed after a call to this method, the
- * results need to be checked and, if an error has occurred, the
- * code should instead cleanup any memory and return.
- */
-jboolean ompi_java_exceptionCheck(JNIEnv *env, int rc)
-{
-    jboolean jni_exception;
-
-    if (rc < 0) {
-        /* handle ompi error code */
-        rc = ompi_errcode_get_mpi_code (rc);
-        /* ompi_mpi_errcode_get_class CAN NOT handle negative error codes.
-         * all Open MPI MPI error codes should be > 0. */
-        assert (rc >= 0);
-    }
-    jni_exception = (*env)->ExceptionCheck(env);
-
-    if(MPI_SUCCESS == rc && JNI_FALSE == jni_exception)
-    {
-        return JNI_FALSE;
-    }
-    else if(MPI_SUCCESS != rc)
-    {
-        int     errClass = ompi_mpi_errcode_get_class(rc);
-        char    *message = ompi_mpi_errnum_get_string(rc);
-        jstring jmessage = (*env)->NewStringUTF(env, (const char*)message);
-
-        jobject mpiex = (*env)->NewObject(env, ompi_java.ExceptionClass,
-                                          ompi_java.ExceptionInit,
-                                          rc, errClass, jmessage);
-        (*env)->Throw(env, mpiex);
-        (*env)->DeleteLocalRef(env, mpiex);
-        (*env)->DeleteLocalRef(env, jmessage);
-        return JNI_TRUE;
-    }
-    /* If we get here, a JNI error has occurred. */
-    return JNI_TRUE;
-}
-
-void* ompi_java_attrSet(JNIEnv *env, jbyteArray jval)
-{
-    int length = (*env)->GetArrayLength(env, jval);
-    void *cval = malloc(sizeof(int) + length);
-    *((int*)cval) = length;
-
-    (*env)->GetByteArrayRegion(env, jval,
-            0, length, (jbyte*)cval + sizeof(int));
-
-    return cval;
-}
-
-jbyteArray ompi_java_attrGet(JNIEnv *env, void *cval)
-{
-    int length = *((int*)cval);
-    jbyteArray jval = (*env)->NewByteArray(env, length);
-
-    (*env)->SetByteArrayRegion(env, jval,
-            0, length, (jbyte*)cval + sizeof(int));
-
-    return jval;
-}
-
-int ompi_java_attrCopy(void *attrValIn, void *attrValOut, int *flag)
-{
-    int length = *((int*)attrValIn) + sizeof(int);
-    *((void**)attrValOut) = malloc(length);
-    memcpy(*((void**)attrValOut), attrValIn, length);
-    *flag = 1;
-    return MPI_SUCCESS;
-}
-
-int ompi_java_attrDelete(void *attrVal)
-{
-    free(attrVal);
-    return MPI_SUCCESS;
-}
diff --git a/ompi/mpi/java/c/mpi_Message.c b/ompi/mpi/java/c/mpi_Message.c
deleted file mode 100644
index b78dc782649..00000000000
--- a/ompi/mpi/java/c/mpi_Message.c
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2016      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#include "ompi_config.h"
-
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Message.h"
-#include "mpiJava.h"
-
-JNIEXPORT void JNICALL Java_mpi_Message_init(JNIEnv *e, jclass c)
-{
-    ompi_java_setStaticLongField(e, c, "NULL",    (jlong)MPI_MESSAGE_NULL);
-    ompi_java_setStaticLongField(e, c, "NO_PROC", (jlong)MPI_MESSAGE_NO_PROC);
-    ompi_java.MessageHandle = (*e)->GetFieldID(e, c, "handle", "J");
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Message_mProbe(
-        JNIEnv *env, jobject jthis,
-        jint source, jint tag, jlong jComm, jlongArray jStatus)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    MPI_Message message;
-    MPI_Status  status;
-    int rc = MPI_Mprobe(source, tag, comm, &message, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, jStatus, &status);
-    
-    return (jlong)message;
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Message_imProbe(
-        JNIEnv *env, jobject jthis, jint source, jint tag, jlong jComm)
-{
-    MPI_Comm comm = (MPI_Comm)jComm;
-    MPI_Message message;
-    MPI_Status  status;
-    int rc, flag;
-    rc = MPI_Improbe(source, tag, comm, &flag, &message, &status);
-
-    if(ompi_java_exceptionCheck(env, rc) || !flag)
-        return NULL;
-
-    (*env)->SetLongField(env, jthis, ompi_java.MessageHandle, (jlong)message);
-    return ompi_java_status_new(env, &status);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Message_mRecv(
-        JNIEnv *env, jobject jthis, jlong jMessage, jobject buf, jboolean db,
-        jint off, jint count, jlong jType, jint bType, jlongArray jStatus)
-{
-    MPI_Message  message = (MPI_Message)jMessage;
-    MPI_Datatype type    = (MPI_Datatype)jType;
-
-    void *ptr;
-    ompi_java_buffer_t *item;
-    ompi_java_getWritePtr(&ptr, &item, env, buf, db, count, type);
-
-    MPI_Status status;
-    int rc = MPI_Mrecv(ptr, count, type, &message, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, jStatus, &status);
-    
-    ompi_java_releaseWritePtr(ptr, item, env, buf, db, off, count, type, bType);
-    return (jlong)message;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Message_imRecv(
-        JNIEnv *env, jobject jthis, jlong jMessage,
-        jobject buf, jint count, jlong jType)
-{
-    MPI_Message  message = (MPI_Message)jMessage;
-    MPI_Datatype type    = (MPI_Datatype)jType;
-    void *ptr = ompi_java_getDirectBufferAddress(env, buf);
-
-    MPI_Request request;
-    int rc = MPI_Imrecv(ptr, count, type, &message, &request);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->SetLongField(env, jthis, ompi_java.MessageHandle, (jlong)message);
-    return (jlong)request;
-}
diff --git a/ompi/mpi/java/c/mpi_Op.c b/ompi/mpi/java/c/mpi_Op.c
deleted file mode 100644
index 90d22fcaa96..00000000000
--- a/ompi/mpi/java/c/mpi_Op.c
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      Research Organization for Information Science
- *                         and Technology (RIST).  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-
-/*
- * File         : mpi_Op.c
- * Headerfile   : mpi_Op.h
- * Author       : Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.7 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-#include "ompi_config.h"
-
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Op.h"
-#include "mpiJava.h"
-#include "ompi/op/op.h"
-
-JNIEXPORT void JNICALL Java_mpi_Op_init(JNIEnv *env, jclass clazz)
-{
-    ompi_java.OpHandle  = (*env)->GetFieldID(env, clazz, "handle", "J");
-    ompi_java.OpCommute = (*env)->GetFieldID(env, clazz, "commute", "Z");
-
-    ompi_java.OpCall = (*env)->GetMethodID(env, clazz, "call",
-                       "(Ljava/lang/Object;Ljava/lang/Object;I)V");
-}
-
-JNIEXPORT void JNICALL Java_mpi_Op_getOp(JNIEnv *env, jobject jthis, jint type)
-{
-    static MPI_Op Ops[] = {
-        MPI_OP_NULL, MPI_MAX, MPI_MIN, MPI_SUM,
-        MPI_PROD, MPI_LAND, MPI_BAND, MPI_LOR, MPI_BOR, MPI_LXOR,
-        MPI_BXOR, MPI_MINLOC, MPI_MAXLOC, MPI_REPLACE, MPI_NO_OP
-    };
-    (*env)->SetLongField(env,jthis, ompi_java.OpHandle, (jlong)Ops[type]);
-}
-
-static jobject setBooleanArray(JNIEnv *env, void *vec, int len)
-{
-    jobject obj = (*env)->NewBooleanArray(env, len);
-
-    if(obj != NULL)
-        (*env)->SetBooleanArrayRegion(env, obj, 0, len, vec);
-
-    return obj;
-}
-
-static void getBooleanArray(JNIEnv *env, jobject obj, void *vec, int len)
-{
-    (*env)->GetBooleanArrayRegion(env, obj, 0, len, vec);
-}
-
-static void opIntercept(void *invec, void *inoutvec, int *count,
-                        MPI_Datatype *datatype, int baseType,
-                        void *jnienv, void *object)
-{
-    JNIEnv  *env  = jnienv;
-    jobject jthis = object;
-    jobject jin, jio;
-
-    MPI_Aint lb, extent;
-    int rc = MPI_Type_get_extent(*datatype, &lb, &extent);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return;
-
-    int len = (*count) * extent;
-
-    if(baseType == 4)
-    {
-        jin = setBooleanArray(env, invec, len);
-        jio = setBooleanArray(env, inoutvec, len);
-    }
-    else
-    {
-        jin = (*env)->NewDirectByteBuffer(env, invec, len);
-        jio = (*env)->NewDirectByteBuffer(env, inoutvec, len);
-    }
-
-    if((*env)->ExceptionCheck(env))
-        return;
-
-    (*env)->CallVoidMethod(env, jthis, ompi_java.OpCall, jin, jio, *count);
-
-    if(baseType == 4)
-        getBooleanArray(env, jio, inoutvec, len);
-
-    (*env)->DeleteLocalRef(env, jin);
-    (*env)->DeleteLocalRef(env, jio);
-}
-
-MPI_Op ompi_java_op_getHandle(JNIEnv *env, jobject jOp, jlong hOp, int baseType)
-{
-    MPI_Op op = (MPI_Op)hOp;
-
-    if(op == NULL)
-    {
-        /* It is an uninitialized user Op. */
-        int commute = (*env)->GetBooleanField(
-                      env, jOp, ompi_java.OpCommute);
-
-        int rc = MPI_Op_create((MPI_User_function*)opIntercept, commute, &op);
-
-        if(ompi_java_exceptionCheck(env, rc))
-            return NULL;
-
-        (*env)->SetLongField(env, jOp, ompi_java.OpHandle, (jlong)op);
-        ompi_op_set_java_callback(op, env, jOp, baseType);
-    }
-
-    return op;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Op_free(JNIEnv *env, jobject jthis)
-{
-    MPI_Op op = (MPI_Op)((*env)->GetLongField(env, jthis, ompi_java.OpHandle));
-
-    if(op != NULL && op != MPI_OP_NULL)
-    {
-        int rc = MPI_Op_free(&op);
-        ompi_java_exceptionCheck(env, rc);
-        ((*env)->SetLongField(env,jthis,ompi_java.OpHandle,(long)MPI_OP_NULL));
-    }
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_Op_isNull(JNIEnv *env, jobject jthis)
-{
-    MPI_Op op = (MPI_Op)((*env)->GetLongField(env, jthis, ompi_java.OpHandle));
-    return op == NULL || op == MPI_OP_NULL ? JNI_TRUE : JNI_FALSE;
-}
diff --git a/ompi/mpi/java/c/mpi_Prequest.c b/ompi/mpi/java/c/mpi_Prequest.c
deleted file mode 100644
index a036d45906e..00000000000
--- a/ompi/mpi/java/c/mpi_Prequest.c
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#include "ompi_config.h"
-#include <stdlib.h>
-#include <assert.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Prequest.h"
-#include "mpiJava.h"
-
-JNIEXPORT jlong JNICALL Java_mpi_Prequest_start(
-        JNIEnv *env, jobject jthis, jlong jRequest)
-{
-    MPI_Request request = (MPI_Request)jRequest;
-    int rc = MPI_Start(&request);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Prequest_startAll(
-        JNIEnv *env, jclass clazz, jlongArray prequests)
-{
-    int count = (*env)->GetArrayLength(env, prequests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, prequests, &jReq, (void***)&cReq);
-    int rc = MPI_Startall(count, cReq);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, prequests, jReq, (void**)cReq);
-}
diff --git a/ompi/mpi/java/c/mpi_Request.c b/ompi/mpi/java/c/mpi_Request.c
deleted file mode 100644
index 81e1d468167..00000000000
--- a/ompi/mpi/java/c/mpi_Request.c
+++ /dev/null
@@ -1,425 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2016      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_Request.c
- * Headerfile   : mpi_Request.h
- * Author       : Sung-Hoon Ko, Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.11 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-#include "ompi_config.h"
-#include <stdlib.h>
-#include <assert.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Request.h"
-#include "mpiJava.h"
-
-JNIEXPORT void JNICALL Java_mpi_Request_init(JNIEnv *env, jclass c)
-{
-    ompi_java.ReqHandle = (*env)->GetFieldID(env, c, "handle", "J");
-}
-
-static void setIndices(JNIEnv *env, jintArray indices, int *cIdx, int count)
-{
-    jint *jIdx;
-
-    if(sizeof(int) == sizeof(jint))
-    {
-        jIdx = cIdx;
-    }
-    else
-    {
-        jIdx = (jint*)calloc(count, sizeof(jint));
-        int i;
-
-        for(i = 0; i < count; i++)
-            jIdx[i] = cIdx[i];
-    }
-
-    (*env)->SetIntArrayRegion(env, indices, 0, count, jIdx);
-
-    if(jIdx != cIdx)
-        free(jIdx);
-}
-
-static jobjectArray newStatuses(JNIEnv *env, MPI_Status *statuses, int count)
-{
-    jobjectArray array = (*env)->NewObjectArray(env,
-                         count, ompi_java.StatusClass, NULL);
-    int i;
-    for(i = 0; i < count; i++)
-    {
-        jobject st = ompi_java_status_new(env, statuses + i);
-        (*env)->SetObjectArrayElement(env, array, i, st);
-        (*env)->DeleteLocalRef(env, st);
-    }
-
-    return array;
-}
-
-static jobjectArray newStatusesIndices(
-        JNIEnv *env, MPI_Status *statuses, int *indices, int count)
-{
-    if(count < 0)
-        return NULL;
-
-    jobjectArray array = (*env)->NewObjectArray(env,
-                         count, ompi_java.StatusClass, NULL);
-    int i;
-    for(i = 0; i < count; i++)
-    {
-        jobject st = ompi_java_status_newIndex(env, statuses + i, indices[i]);
-        (*env)->SetObjectArrayElement(env, array, i, st);
-        (*env)->DeleteLocalRef(env, st);
-    }
-
-    return array;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Request_getNull(JNIEnv *env, jclass clazz)
-{
-    return (jlong)MPI_REQUEST_NULL;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Request_cancel(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Request req = (MPI_Request)handle;
-    int rc = MPI_Cancel(&req);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Request_free(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Request req = (MPI_Request)handle;
-    int rc = MPI_Request_free(&req);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)req;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Request_waitStatus(
-        JNIEnv *env, jobject jthis, jlong handle, jlongArray stat)
-{
-    MPI_Request req = (MPI_Request)handle;
-    MPI_Status status;
-    int rc = MPI_Wait(&req, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        ompi_java_status_set(env, stat, &status);
-    
-    return (jlong)req;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Request_waitFor(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Request req = (MPI_Request)handle;
-    int rc = MPI_Wait(&req, MPI_STATUS_IGNORE);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)req;
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Request_testStatus(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Request req = (MPI_Request)handle;
-    int flag;
-    MPI_Status status;
-    int rc = MPI_Test(&req, &flag, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        (*env)->SetLongField(env, jthis, ompi_java.ReqHandle, (jlong)req);
-    
-    return flag ? ompi_java_status_new(env, &status) : NULL;
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Request_getStatus(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Request req = (MPI_Request)handle;
-    int flag;
-    MPI_Status status;
-    int rc = MPI_Request_get_status(req, &flag, &status);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        (*env)->SetLongField(env, jthis, ompi_java.ReqHandle, (jlong)req);
-    
-    return flag ? ompi_java_status_new(env, &status) : NULL;
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_Request_test(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Request req = (MPI_Request)handle;
-    int flag;
-    int rc = MPI_Test(&req, &flag, MPI_STATUS_IGNORE);
-    
-    if(!ompi_java_exceptionCheck(env, rc))
-        (*env)->SetLongField(env, jthis, ompi_java.ReqHandle, (jlong)req);
-    
-    return flag ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Request_waitAnyStatus(
-        JNIEnv *env, jclass clazz, jlongArray requests, jobject stat)
-{
-    jboolean exception;
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int index;
-    MPI_Status status;
-    int rc = MPI_Waitany(count, cReq, &index, &status);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    
-    if(!exception)
-        ompi_java_status_setIndex(env, stat, &status, index);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Request_waitAny(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int index;
-    int rc = MPI_Waitany(count, cReq, &index, MPI_STATUS_IGNORE);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    return index;
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Request_testAnyStatus(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int index, flag;
-    MPI_Status status;
-    int rc = MPI_Testany(count, cReq, &index, &flag, &status);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    return flag ? ompi_java_status_newIndex(env, &status, index) : NULL;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Request_testAny(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int index, flag;
-    int rc = MPI_Testany(count, cReq, &index, &flag, MPI_STATUS_IGNORE);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    return index;
-}
-
-JNIEXPORT jobjectArray JNICALL Java_mpi_Request_waitAllStatus(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    MPI_Status *statuses = (MPI_Status*)calloc(count, sizeof(MPI_Status));
-    int rc = MPI_Waitall(count, cReq, statuses);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    jobjectArray jStatuses = newStatuses(env, statuses, count);
-    free(statuses);
-    return jStatuses;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Request_waitAll(
-        JNIEnv *env, jclass jthis, jlongArray requests)
-{
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int rc = MPI_Waitall(count, cReq, MPI_STATUSES_IGNORE);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-}
-
-JNIEXPORT jobjectArray JNICALL Java_mpi_Request_testAllStatus(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    MPI_Status *statuses = (MPI_Status*)calloc(count, sizeof(MPI_Status));
-    int flag;
-    int rc = MPI_Testall(count, cReq, &flag, statuses);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    jobjectArray jStatuses = flag ? newStatuses(env, statuses, count) : NULL;
-    free(statuses);
-    return jStatuses;
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_Request_testAll(
-        JNIEnv *env, jclass jthis, jlongArray requests)
-{
-    int count = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int flag;
-    int rc = MPI_Testall(count, cReq, &flag, MPI_STATUSES_IGNORE);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    return flag ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT jobjectArray JNICALL Java_mpi_Request_waitSomeStatus(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    int incount = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    MPI_Status *statuses = (MPI_Status*)calloc(incount, sizeof(MPI_Status));
-    int *indices = (int*)calloc(incount, sizeof(int));
-    int outcount;
-    int rc = MPI_Waitsome(incount, cReq, &outcount, indices, statuses);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    jobjectArray jStatuses = newStatusesIndices(env, statuses, indices, outcount);
-    free(statuses);
-    free(indices);
-    return jStatuses;
-}
-
-JNIEXPORT jintArray JNICALL Java_mpi_Request_waitSome(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    jboolean exception;
-    int incount = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int *indices = (int*)calloc(incount, sizeof(int));
-    int outcount;
-    int rc = MPI_Waitsome(incount, cReq, &outcount, indices, MPI_STATUSES_IGNORE);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    
-    if(exception) {
-        free(indices);
-        return NULL;
-    }
-
-    jintArray jindices = NULL;
-
-    if(outcount != MPI_UNDEFINED)
-    {
-        jindices = (*env)->NewIntArray(env, outcount);
-        setIndices(env, jindices, indices, outcount);
-    }
-
-    free(indices);
-    return jindices;
-}
-
-JNIEXPORT jobjectArray JNICALL Java_mpi_Request_testSomeStatus(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    int incount = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    MPI_Status *statuses = (MPI_Status*)calloc(incount, sizeof(MPI_Status));
-    int *indices = (int*)calloc(incount, sizeof(int));
-    int outcount;
-    int rc = MPI_Testsome(incount, cReq, &outcount, indices, statuses);
-    ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    jobjectArray jStatuses = newStatusesIndices(env, statuses, indices, outcount);
-    free(statuses);
-    free(indices);
-    return jStatuses;
-}
-
-JNIEXPORT jintArray JNICALL Java_mpi_Request_testSome(
-        JNIEnv *env, jclass clazz, jlongArray requests)
-{
-    jboolean exception;
-    int incount = (*env)->GetArrayLength(env, requests);
-    jlong* jReq;
-    MPI_Request *cReq;
-    ompi_java_getPtrArray(env, requests, &jReq, (void***)&cReq);
-    int *indices = (int*)calloc(incount, sizeof(int));
-    int outcount;
-    int rc = MPI_Testsome(incount, cReq, &outcount, indices, MPI_STATUSES_IGNORE);
-    exception = ompi_java_exceptionCheck(env, rc);
-    ompi_java_releasePtrArray(env, requests, jReq, (void**)cReq);
-    
-    if(exception) {
-        free(indices);
-        return NULL;
-    }
-    
-    jintArray jindices = NULL;
-
-    if(outcount != MPI_UNDEFINED)
-    {
-        jindices = (*env)->NewIntArray(env, outcount);
-        setIndices(env, jindices, indices, outcount);
-    }
-
-    free(indices);
-    return jindices;
-}
diff --git a/ompi/mpi/java/c/mpi_Status.c b/ompi/mpi/java/c/mpi_Status.c
deleted file mode 100644
index 0863a872b7f..00000000000
--- a/ompi/mpi/java/c/mpi_Status.c
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-*/
-/*
- * File         : mpi_Status.c
- * Headerfile   : mpi_Status.h
- * Author       : Sung-Hoon Ko, Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.9 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Status.h"
-#include "mpiJava.h"
-
-static void getStatus(MPI_Status *status, jint source, jint tag,
-                      jint error, jint cancelled, jlong ucount)
-{
-    /* Copy the whole thing to C */
-    status->MPI_SOURCE = source;
-    status->MPI_TAG    = tag;
-    status->MPI_ERROR  = error;
-    status->_cancelled = cancelled;
-    status->_ucount    = ucount;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Status_init(JNIEnv *env, jclass clazz)
-{
-    ompi_java.StatusData = (*env)->GetFieldID(env, clazz, "data", "[J");
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Status_getCount(
-        JNIEnv *env, jobject jthis, jint source, jint tag,
-        jint error, jint cancelled, jlong ucount, jlong jType)
-{
-    int count;
-    MPI_Status stat;
-    getStatus(&stat, source, tag, error, cancelled, ucount);
-    MPI_Datatype datatype = (MPI_Datatype)jType;
-    int rc = MPI_Get_count(&stat, datatype, &count);
-    ompi_java_exceptionCheck(env, rc);
-    return count;
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_Status_isCancelled(
-        JNIEnv *env, jobject jthis, jint source, jint tag,
-        jint error, jint cancelled, jlong ucount)
-{
-    int flag;
-    MPI_Status stat;
-    getStatus(&stat, source, tag, error, cancelled, ucount);
-    int rc = MPI_Test_cancelled(&stat, &flag);
-    ompi_java_exceptionCheck(env, rc);
-    return flag==0 ? JNI_FALSE : JNI_TRUE;
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Status_getElements(
-        JNIEnv *env, jobject jthis, jint source, jint tag,
-        jint error, jint cancelled, jlong ucount, jlong jType)
-{
-    int count;
-    MPI_Status stat;
-    getStatus(&stat, source, tag, error, cancelled, ucount);
-    MPI_Datatype datatype = (MPI_Datatype)jType;
-    int rc = MPI_Get_elements(&stat, datatype, &count);
-    ompi_java_exceptionCheck(env, rc);
-    return count;
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Status_getElementsX(
-        JNIEnv *env, jobject jthis, jint source, jint tag,
-        jint error, jint cancelled, jlong ucount, jlong jType)
-{
-    MPI_Count count;
-    MPI_Status stat;
-    getStatus(&stat, source, tag, error, cancelled, ucount);
-    MPI_Datatype datatype = (MPI_Datatype)jType;
-    int rc = MPI_Get_elements_x(&stat, datatype, &count);
-    ompi_java_exceptionCheck(env, rc);
-
-	return (*env)->NewObject(env, ompi_java.CountClass,
-				ompi_java.CountInit, (jlong)count);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Status_setElements(
-        JNIEnv *env, jobject jthis, jint source, jint tag,
-        jint error, jint cancelled, jlong ucount, jlong jType, int count)
-{
-    MPI_Status stat;
-    getStatus(&stat, source, tag, error, cancelled, ucount);
-    MPI_Datatype datatype = (MPI_Datatype)jType;
-    int rc = MPI_Status_set_elements(&stat, datatype, count);
-    ompi_java_exceptionCheck(env, rc);
-    return stat._ucount;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Status_setElementsX(
-        JNIEnv *env, jobject jthis, jint source, jint tag,
-        jint error, jint cancelled, jlong ucount, jlong jType, jlong jcount)
-{
-    MPI_Status stat;
-    MPI_Count count = (long)jcount;
-    getStatus(&stat, source, tag, error, cancelled, ucount);
-    MPI_Datatype datatype = (MPI_Datatype)jType;
-    int rc = MPI_Status_set_elements_x(&stat, datatype, count);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)stat._ucount;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Status_setCancelled(
-        JNIEnv *env, jobject jthis, jint source, jint tag,
-        jint error, jint cancelled, jlong ucount, int flag)
-{
-    MPI_Status stat;
-    getStatus(&stat, source, tag, error, cancelled, ucount);
-    int rc = MPI_Status_set_cancelled(&stat, flag);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-jobject ompi_java_status_new(JNIEnv *env, MPI_Status *status)
-{
-    jlongArray jData = (*env)->NewLongArray(env, 6);
-    ompi_java_status_set(env, jData, status);
-    jobject jStatus = (*env)->AllocObject(env, ompi_java.StatusClass);
-    (*env)->SetObjectField(env, jStatus, ompi_java.StatusData, jData);
-    return jStatus;
-}
-
-jobject ompi_java_status_newIndex(JNIEnv *env, MPI_Status *status, int index)
-{
-    jlongArray jData = (*env)->NewLongArray(env, 6);
-    ompi_java_status_setIndex(env, jData, status, index);
-    jobject jStatus = (*env)->AllocObject(env, ompi_java.StatusClass);
-    (*env)->SetObjectField(env, jStatus, ompi_java.StatusData, jData);
-    return jStatus;
-}
-
-void ompi_java_status_set(JNIEnv *env, jlongArray jData, MPI_Status *status)
-{
-    /* Copy the whole thing to Java */
-    int i = 0;
-    jlong *data = (*env)->GetPrimitiveArrayCritical(env, jData, NULL);
-    data[i++] = status->MPI_SOURCE;
-    data[i++] = status->MPI_TAG;
-    data[i++] = status->MPI_ERROR;
-    data[i++] = status->_cancelled;
-    data[i++] = status->_ucount;
-    (*env)->ReleasePrimitiveArrayCritical(env, jData, data, 0);
-}
-
-void ompi_java_status_setIndex(
-        JNIEnv *env, jlongArray jData, MPI_Status *status, int index)
-{
-    /* Copy the whole thing to Java */
-    int i = 0;
-    jlong *data = (*env)->GetPrimitiveArrayCritical(env, jData, NULL);
-    data[i++] = status->MPI_SOURCE;
-    data[i++] = status->MPI_TAG;
-    data[i++] = status->MPI_ERROR;
-    data[i++] = status->_cancelled;
-    data[i++] = status->_ucount;
-    data[i++] = index;
-    (*env)->ReleasePrimitiveArrayCritical(env, jData, data, 0);
-}
diff --git a/ompi/mpi/java/c/mpi_Win.c b/ompi/mpi/java/c/mpi_Win.c
deleted file mode 100644
index 551b6e258e6..00000000000
--- a/ompi/mpi/java/c/mpi_Win.c
+++ /dev/null
@@ -1,508 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-#include "ompi_config.h"
-
-#include <stdlib.h>
-#ifdef HAVE_TARGETCONDITIONALS_H
-#include <TargetConditionals.h>
-#endif
-
-#include "mpi.h"
-#include "mpi_Win.h"
-#include "mpiJava.h"
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_createWin(
-        JNIEnv *env, jobject jthis, jobject jBase,
-        jint size, jint dispUnit, jlong info, jlong comm)
-{
-    void *base = (*env)->GetDirectBufferAddress(env, jBase);
-    MPI_Win win;
-
-    int rc = MPI_Win_create(base, (MPI_Aint)size, dispUnit,
-                            (MPI_Info)info, (MPI_Comm)comm, &win);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)win;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_allocateWin(JNIEnv *env, jobject jthis,
-                                                 jint size, jint dispUnit, jlong info, jlong comm, jobject jBase)
-{
-    void *basePtr = (*env)->GetDirectBufferAddress(env, jBase);
-    MPI_Win win;
-
-    int rc = MPI_Win_allocate((MPI_Aint)size, dispUnit,
-                              (MPI_Info)info, (MPI_Comm)comm, basePtr, &win);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)win;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_allocateSharedWin(JNIEnv *env, jobject jthis,
-                                                       jint size, jint dispUnit, jlong info, jlong comm, jobject jBase)
-{
-    void *basePtr = (*env)->GetDirectBufferAddress(env, jBase);
-    MPI_Win win;
-
-    int rc = MPI_Win_allocate_shared((MPI_Aint)size, dispUnit,
-                                     (MPI_Info)info, (MPI_Comm)comm, basePtr, &win);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)win;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_createDynamicWin(
-        JNIEnv *env, jobject jthis,
-        jlong info, jlong comm)
-{
-    MPI_Win win;
-
-    int rc = MPI_Win_create_dynamic(
-                            (MPI_Info)info, (MPI_Comm)comm, &win);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)win;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_attach(
-        JNIEnv *env, jobject jthis, jlong win, jobject jBase,
-        jint size)
-{
-    void *base = (*env)->GetDirectBufferAddress(env, jBase);
-
-    int rc = MPI_Win_attach((MPI_Win)win, base, (MPI_Aint)size);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_detach(
-        JNIEnv *env, jobject jthis, jlong win, jobject jBase)
-{
-    void *base = (*env)->GetDirectBufferAddress(env, jBase);
-
-    int rc = MPI_Win_detach((MPI_Win)win, base);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_getGroup(
-        JNIEnv *env, jobject jthis, jlong win)
-{
-    MPI_Group group;
-    int rc = MPI_Win_get_group((MPI_Win)win, &group);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)group;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_put(
-        JNIEnv *env, jobject jthis, jlong win, jobject origin,
-        jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
-        jint targetCount, jlong targetType, jint baseType)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-
-    int rc = MPI_Put(orgPtr, orgCount, (MPI_Datatype)orgType,
-                     targetRank, (MPI_Aint)targetDisp, targetCount,
-                     (MPI_Datatype)targetType, (MPI_Win)win);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_get(
-        JNIEnv *env, jobject jthis, jlong win, jobject origin,
-        jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
-        jint targetCount, jlong targetType, jint baseType)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-
-    int rc = MPI_Get(orgPtr, orgCount, (MPI_Datatype)orgType,
-                     targetRank, (MPI_Aint)targetDisp, targetCount,
-                     (MPI_Datatype)targetType, (MPI_Win)win);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_accumulate(
-        JNIEnv *env, jobject jthis, jlong win,
-        jobject origin, jint orgCount, jlong orgType,
-        jint targetRank, jint targetDisp, jint targetCount, jlong targetType,
-        jobject jOp, jlong hOp, jint baseType)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
-
-    int rc = MPI_Accumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
-                            targetRank, (MPI_Aint)targetDisp, targetCount,
-                            (MPI_Datatype)targetType, op, (MPI_Win)win);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_fence(
-        JNIEnv *env, jobject jthis, jlong win, jint assertion)
-{
-    int rc = MPI_Win_fence(assertion, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_start(
-        JNIEnv *env, jobject jthis, jlong win, jlong group, jint assertion)
-{
-    int rc = MPI_Win_start((MPI_Group)group, assertion, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_complete(
-        JNIEnv *env, jobject jthis, jlong win)
-{
-    int rc = MPI_Win_complete((MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_post(
-        JNIEnv *env, jobject jthis, jlong win, jlong group, jint assertion)
-{
-    int rc = MPI_Win_post((MPI_Group)group, assertion, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_waitFor(
-        JNIEnv *env, jobject jthis, jlong win)
-{
-    int rc = MPI_Win_wait((MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jboolean JNICALL Java_mpi_Win_test(
-        JNIEnv *env, jobject jthis, jlong win)
-{
-    int flag;
-    int rc = MPI_Win_test((MPI_Win)win, &flag);
-    ompi_java_exceptionCheck(env, rc);
-    return flag ? JNI_TRUE : JNI_FALSE;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_lock(
-        JNIEnv *env, jobject jthis, jlong win,
-        jint lockType, jint rank, jint assertion)
-{
-    int rc = MPI_Win_lock(lockType, rank, assertion, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_unlock(
-        JNIEnv *env, jobject jthis, jlong win, jint rank)
-{
-    int rc = MPI_Win_unlock(rank, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_setErrhandler(
-        JNIEnv *env, jobject jthis, jlong win, jlong errhandler)
-{
-    int rc = MPI_Win_set_errhandler(
-             (MPI_Win)win, (MPI_Errhandler)errhandler);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_getErrhandler(
-        JNIEnv *env, jobject jthis, jlong win)
-{
-    MPI_Errhandler errhandler;
-    int rc = MPI_Win_get_errhandler((MPI_Win)win, &errhandler);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)errhandler;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_callErrhandler(
-        JNIEnv *env, jobject jthis, jlong win, jint errorCode)
-{
-    int rc = MPI_Win_call_errhandler((MPI_Win)win, errorCode);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-static int winCopyAttr(MPI_Win oldwin, int keyval, void *extraState,
-                       void *attrValIn, void *attrValOut, int *flag)
-{
-    return ompi_java_attrCopy(attrValIn, attrValOut, flag);
-}
-
-static int winDeleteAttr(MPI_Win oldwin, int keyval,
-                         void *attrVal, void *extraState)
-{
-    return ompi_java_attrDelete(attrVal);
-}
-
-JNIEXPORT jint JNICALL Java_mpi_Win_createKeyval_1jni(JNIEnv *env, jclass clazz)
-{
-    int rc, keyval;
-    rc = MPI_Win_create_keyval(winCopyAttr, winDeleteAttr, &keyval, NULL);
-    ompi_java_exceptionCheck(env, rc);
-    return keyval;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_freeKeyval_1jni(
-        JNIEnv *env, jclass clazz, jint keyval)
-{
-    int rc = MPI_Win_free_keyval((int*)(&keyval));
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_setAttr(
-        JNIEnv *env, jobject jthis, jlong win, jint keyval, jbyteArray jval)
-{
-    void *cval = ompi_java_attrSet(env, jval);
-    int rc = MPI_Win_set_attr((MPI_Win)win, keyval, cval);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jobject JNICALL Java_mpi_Win_getAttr(
-        JNIEnv *env, jobject jthis, jlong win, jint keyval)
-{
-    int flag;
-    void *val;
-    int rc = MPI_Win_get_attr((MPI_Win)win, keyval, &val, &flag);
-
-    if(ompi_java_exceptionCheck(env, rc) || !flag)
-        return NULL;
-
-    switch(keyval)
-    {
-        case MPI_WIN_SIZE:
-            return ompi_java_Integer_valueOf(env, (jint)(*((MPI_Aint*)val)));
-        case MPI_WIN_DISP_UNIT:
-            return ompi_java_Integer_valueOf(env, (jint)(*((int*)val)));
-        case MPI_WIN_BASE:
-            return ompi_java_Long_valueOf(env, (jlong)val);
-        default:
-            return ompi_java_attrGet(env, val);
-    }
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_deleteAttr(
-        JNIEnv *env, jobject jthis, jlong win, jint keyval)
-{
-    int rc = MPI_Win_delete_attr((MPI_Win)win, keyval);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_free(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Win win = (MPI_Win)handle;
-    int rc = MPI_Win_free(&win);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)win;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_getInfo(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    MPI_Win win = (MPI_Win)handle;
-    MPI_Info info;
-    int rc = MPI_Win_get_info((MPI_Win)win, &info);
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)info;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_setInfo(
-        JNIEnv *env, jobject jthis, jlong handle, jlong i)
-{
-    MPI_Win win = (MPI_Win)handle;
-    MPI_Info info = (MPI_Info)i;
-    int rc = MPI_Win_set_info(win, info);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_rPut(JNIEnv *env, jobject jthis,
-    jlong win, jobject origin_addr, jint origin_count, jlong origin_type,
-    jint target_rank, jint target_disp, jint target_count, jlong target_datatype,
-    jint basetype)
-{
-    void *origPtr = ompi_java_getDirectBufferAddress(env, origin_addr);
-    MPI_Request request;
-
-    int rc = MPI_Rput(origPtr, origin_count, (MPI_Datatype)origin_type,
-                      target_rank, (MPI_Aint)target_disp, target_count, (MPI_Datatype)target_datatype,
-                      (MPI_Win)win, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_rGet(JNIEnv *env, jobject jthis, jlong win,
-    jobject origin, jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
-    jint targetCount, jlong targetType, jint base)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-    MPI_Request request;
-
-    int rc = MPI_Rget(orgPtr, orgCount, (MPI_Datatype)orgType,
-                      targetRank, (MPI_Aint)targetDisp, targetCount,
-                      (MPI_Datatype)targetType, (MPI_Win)win, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_rAccumulate(JNIEnv *env, jobject jthis, jlong win,
-    jobject origin, jint orgCount, jlong orgType, jint targetRank, jint targetDisp,
-    jint targetCount, jlong targetType, jobject jOp, jlong hOp, jint baseType)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
-    MPI_Request request;
-
-    int rc = MPI_Raccumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
-                            targetRank, (MPI_Aint)targetDisp, targetCount,
-                            (MPI_Datatype)targetType, op, (MPI_Win)win, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_getAccumulate(JNIEnv *env, jobject jthis, jlong win,
-                            jobject origin, jint orgCount, jlong orgType, jobject resultBuff, jint resultCount,
-                                                  jlong resultType, jint targetRank, jint targetDisp, jint targetCount, jlong targetType,
-                                                  jobject jOp, jlong hOp, jint baseType)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-    void *resultPtr = (*env)->GetDirectBufferAddress(env, resultBuff);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
-
-    int rc = MPI_Get_accumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
-                                resultPtr, resultCount, (MPI_Datatype)resultType,
-                                targetRank, (MPI_Aint)targetDisp, targetCount,
-                                (MPI_Datatype)targetType, op, (MPI_Win)win);
-
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT jlong JNICALL Java_mpi_Win_rGetAccumulate(JNIEnv *env, jobject jthis, jlong win,
-                                                    jobject origin, jint orgCount, jlong orgType, jobject resultBuff, jint resultCount,
-                                                    jlong resultType, jint targetRank, jint targetDisp, jint targetCount, jlong targetType,
-                                                    jobject jOp, jlong hOp, jint baseType)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-    void *resultPtr = (*env)->GetDirectBufferAddress(env, resultBuff);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
-    MPI_Request request;
-
-    int rc = MPI_Rget_accumulate(orgPtr, orgCount, (MPI_Datatype)orgType,
-                                 resultPtr, resultCount, (MPI_Datatype)resultType,
-                                 targetRank, (MPI_Aint)targetDisp, targetCount,
-                                 (MPI_Datatype)targetType, op, (MPI_Win)win, &request);
-
-    ompi_java_exceptionCheck(env, rc);
-    return (jlong)request;
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_lockAll(JNIEnv *env, jobject jthis, jlong win, jint assertion)
-{
-    int rc = MPI_Win_lock_all(assertion, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_unlockAll(JNIEnv *env, jobject jthis, jlong win)
-{
-    int rc = MPI_Win_unlock_all((MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_sync(JNIEnv *env, jobject jthis, jlong win)
-{
-    int rc = MPI_Win_sync((MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_flush(JNIEnv *env, jobject jthis, jlong win, jint targetRank)
-{
-    int rc = MPI_Win_flush(targetRank, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_flushAll(JNIEnv *env, jobject jthis, jlong win)
-{
-    int rc = MPI_Win_flush_all((MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_compareAndSwap (JNIEnv *env, jobject jthis, jlong win, jobject origin,
-                                                    jobject compareAddr, jobject resultAddr, jlong dataType, jint targetRank, jint targetDisp)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-    void *compPtr = (*env)->GetDirectBufferAddress(env, compareAddr);
-    void *resultPtr = (*env)->GetDirectBufferAddress(env, resultAddr);
-
-    int rc = MPI_Compare_and_swap(orgPtr, compPtr, resultPtr, (MPI_Datatype)dataType, 
-	targetRank, targetDisp, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_fetchAndOp(JNIEnv *env, jobject jthis, jlong win, jobject origin,
-                                               jobject resultAddr, jlong dataType, jint targetRank, jint targetDisp, jobject jOp, jlong hOp, jint baseType)
-{
-    void *orgPtr = (*env)->GetDirectBufferAddress(env, origin);
-    void *resultPtr = (*env)->GetDirectBufferAddress(env, resultAddr);
-    MPI_Op op = ompi_java_op_getHandle(env, jOp, hOp, baseType);
-
-    int rc = MPI_Fetch_and_op(orgPtr, resultPtr, (MPI_Datatype)dataType, targetRank, 
-	targetDisp, op, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_flushLocal(JNIEnv *env, jobject jthis, jlong win, jint targetRank)
-{
-    int rc = MPI_Win_flush_local(targetRank, (MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_flushLocalAll(JNIEnv *env, jobject jthis, jlong win)
-{
-    int rc = MPI_Win_flush_local_all((MPI_Win)win);
-    ompi_java_exceptionCheck(env, rc);
-}
-
-JNIEXPORT void JNICALL Java_mpi_Win_setName(
-        JNIEnv *env, jobject jthis, jlong handle, jstring jname)
-{
-    const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
-    int rc = MPI_Win_set_name((MPI_Win)handle, (char*)name);
-    ompi_java_exceptionCheck(env, rc);
-    (*env)->ReleaseStringUTFChars(env, jname, name);
-}
-
-JNIEXPORT jstring JNICALL Java_mpi_Win_getName(
-        JNIEnv *env, jobject jthis, jlong handle)
-{
-    char name[MPI_MAX_OBJECT_NAME];
-    int len;
-    int rc = MPI_Win_get_name((MPI_Win)handle, name, &len);
-
-    if(ompi_java_exceptionCheck(env, rc))
-        return NULL;
-
-    return (*env)->NewStringUTF(env, name);
-}
diff --git a/ompi/mpi/java/java/CartComm.java b/ompi/mpi/java/java/CartComm.java
deleted file mode 100644
index 4c49262e0e8..00000000000
--- a/ompi/mpi/java/java/CartComm.java
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Cartcomm.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.7 $
- * Updated      : $Date: 2001/10/22 21:07:55 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * Communicator with cartesian structure.
- */
-public final class CartComm extends Intracomm
-{
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	protected CartComm(long handle) throws MPIException
-	{
-		super(handle);
-	}
-
-	protected CartComm(long[] commRequest)
-	{
-		super(commRequest);
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * <p>It is recommended to use {@link #dup} instead of {@link #clone}
-	 * because the last can't throw an {@link mpi.MPIException}.
-	 * @return copy of this communicator
-	 */
-	@Override public CartComm clone()
-	{
-		try
-		{
-			return dup();
-		}
-		catch(MPIException e)
-		{
-			throw new RuntimeException(e.getMessage());
-		}
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public CartComm dup() throws MPIException
-	{
-		MPI.check();
-		return new CartComm(dup(handle));
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_IDUP}.
-	 * <p>The new communicator can't be used before the operation completes.
-	 * The request object must be obtained calling {@link #getRequest}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred. Signals that an MPI exception of some sort has occurred.
-	 */
-	@Override public CartComm iDup() throws MPIException
-	{
-		MPI.check();
-		return new CartComm(iDup(handle));
-	}
-
-	/**
-	* Duplicates this communicator with the info object used in the call.
-	* <p>Java binding of {@code MPI_COMM_DUP_WITH_INFO}.
-	* @param info	info object to associate with the new communicator
-	* @return copy of this communicator
-	* @throws MPIException Signals that an MPI error of some sort has occurred.
-	*/
-	@Override public CartComm dupWithInfo(Info info) throws MPIException
-	{
-	    MPI.check();
-	    return new CartComm(dupWithInfo(handle, info.handle));
-	}
-
-	/**
-	 * Returns cartesian topology information.
-	 * <p>Java binding of the MPI operations {@code MPI_CARTDIM_GET} and
-	 * {@code MPI_CART_GET}.
-	 * <p>The number of dimensions can be obtained from the size of (eg)
-	 * {@code dims} field of the returned object.
-	 * @return object containing dimensions, periods and local coordinates
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public CartParms getTopo() throws MPIException
-	{
-		MPI.check();
-		return getTopo(handle);
-	}
-
-	private native CartParms getTopo(long comm) throws MPIException;
-
-	/**
-	 * Translate logical process coordinates to process rank.
-	 * <p>Java binding of the MPI operation {@code MPI_CART_RANK}.
-	 * @param coords Cartesian coordinates of a process
-	 * @return rank of the specified process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getRank(int[] coords) throws MPIException
-	{
-		MPI.check();
-		return getRank(handle, coords);
-	}
-
-	private native int getRank(long comm, int[] coords) throws MPIException;
-
-	/**
-	 * Translate process rank to logical process coordinates.
-	 * <p>Java binding of the MPI operation {@code MPI_CART_COORDS}.
-	 * @param rank rank of a process
-	 * @return Cartesian coordinates of the specified process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int[] getCoords(int rank) throws MPIException
-	{
-		MPI.check();
-		return getCoords(handle, rank);
-	}
-
-	private native int[] getCoords(long comm, int rank) throws MPIException;
-
-	/**
-	 * Compute source and destination ranks for "shift" communication.
-	 * <p>Java binding of the MPI operation {@code MPI_CART_SHIFT}.
-	 * @param direction coordinate dimension of shift
-	 * @param disp      displacement
-	 * @return object containing ranks of source and destination processes
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public ShiftParms shift(int direction, int disp) throws MPIException
-	{
-		MPI.check();
-		return shift(handle, direction, disp);
-	}
-
-	private native ShiftParms shift(long comm, int direction, int disp)
-			throws MPIException;
-
-	/**
-	 * Partition cartesian communicator into subgroups of lower dimension.
-	 * <p>Java binding of the MPI operation {@code MPI_CART_SUB}.
-	 * @param remainDims by dimension, {@code true} if dimension is to be kept,
-	 *                   {@code false} otherwise
-	 * @return communicator containing subgrid including this process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public CartComm sub(boolean[] remainDims) throws MPIException
-	{
-		MPI.check();
-		return new CartComm(sub(handle, remainDims));
-	}
-
-	private native long sub(long comm, boolean[] remainDims) throws MPIException;
-
-	/**
-	 * Compute an optimal placement.
-	 * <p>Java binding of the MPI operation {@code MPI_CART_MAP}.
-	 * <p>The number of dimensions is taken to be size of the {@code dims} argument.
-	 * @param dims    the number of processes in each dimension
-	 * @param periods {@code true} if grid is periodic,
-	 *                {@code false} if not, in each dimension
-	 * @return reordered rank of calling process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int map(int[] dims, boolean[] periods) throws MPIException
-	{
-		MPI.check();
-		return map(handle, dims, periods);
-	}
-
-	private native int map(long comm, int[] dims, boolean[] periods)
-			throws MPIException;
-
-	/**
-	 * Select a balanced distribution of processes per coordinate direction.
-	 * <p>Java binding of the MPI operation {@code MPI_DIMS_CREATE}.
-	 * @param nnodes number of nodes in a grid
-	 * @param dims   array specifying the number of nodes in each dimension
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void createDims(int nnodes, int[] dims) throws MPIException
-	{
-		MPI.check();
-		createDims_jni(nnodes, dims);
-	}
-
-	private static native void createDims_jni(int nnodes, int[] dims)
-			throws MPIException;
-
-} // Cartcomm
diff --git a/ompi/mpi/java/java/CartParms.java b/ompi/mpi/java/java/CartParms.java
deleted file mode 100644
index aefd2d8fe5b..00000000000
--- a/ompi/mpi/java/java/CartParms.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : CartParms.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.1 $
- * Updated      : $Date: 1998/08/26 18:49:50 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * Cartesian topology information associated with a communicator.
- */
-public final class CartParms
-{
-	/** Number of processes for each cartesian dimension. */
-	private final int[] dims;
-
-	/** Periodicity (true/false) for each cartesian dimension. */
-	private final boolean[] periods;
-
-	/** Coordinates of calling process in cartesian structure. */
-	private final int[] coords;
-
-	/**
-	 * Constructs a cartesian topology information object.
-	 * @param dims    number of processes for each cartesian dimension.
-	 * @param periods periodicity (true/false) for each cartesian dimension.
-	 * @param coords  coordinates of calling process in cartesian structure.
-	 */
-	protected CartParms(int[] dims, boolean[] periods, int[] coords)
-	{
-		this.dims    = dims;
-		this.periods = periods;
-		this.coords  = coords;
-	}
-
-	/**
-	 * Returns the number of dimensions.
-	 * @return number of dimensions.
-	 */
-	public int getDimCount()
-	{
-		return dims.length;
-	}
-
-	/**
-	 * Returns the number of processes for a cartesian dimension.
-	 * @param i cartesian dimension.
-	 * @return number of processes for a cartesian dimension.
-	 */
-	public int getDim(int i)
-	{
-		return dims[i];
-	}
-
-	/**
-	 * Returns the periodicity (true/false) for a cartesian dimension.
-	 * @param i cartesian dimension.
-	 * @return periodicity for a cartesian dimension.
-	 */
-	public boolean getPeriod(int i)
-	{
-		return periods[i];
-	}
-
-	/**
-	 * Returns the coordinate of calling process for a cartesian dimension.
-	 * @param i cartesian dimension.
-	 * @return coordinate of calling process for a cartesian dimension.
-	 */
-	public int getCoord(int i)
-	{
-		return coords[i];
-	}
-
-} // CartParms
diff --git a/ompi/mpi/java/java/Comm.java b/ompi/mpi/java/java/Comm.java
deleted file mode 100644
index 7483e8987f3..00000000000
--- a/ompi/mpi/java/java/Comm.java
+++ /dev/null
@@ -1,3469 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2017-2019 FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Comm.java
- * Author       : Sang Lim, Sung-Hoon Ko, Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.20 $
- * Updated      : $Date: 2001/08/07 16:36:25 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- *
- *
- *
- * IMPLEMENTATION DETAILS
- *
- * All methods with buffers that can be direct or non direct have
- * a companion argument 'db' which is true if the buffer is direct.
- * For example, if the buffer argument is recvBuf, the companion
- * argument will be 'rdb', meaning if the receive buffer is direct.
- *
- * Checking if a buffer is direct is faster in Java than C.
- */
-package mpi;
-
-import java.nio.*;
-import static mpi.MPI.assertDirectBuffer;
-
-/**
- * The {@code Comm} class represents communicators.
- */
-public class Comm implements Freeable, Cloneable
-{
-	public final static int TYPE_SHARED = 0;
-	protected final static int SELF  = 1;
-	protected final static int WORLD = 2;
-	protected long handle;
-	private Request request;
-
-	private static long nullHandle;
-
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	protected Comm()
-	{
-	}
-
-	protected Comm(long handle)
-	{
-		this.handle = handle;
-	}
-
-	protected Comm(long[] commRequest)
-	{
-		handle  = commRequest[0];
-		request = new Request(commRequest[1]);
-	}
-
-	protected final void setType(int type)
-	{
-		getComm(type);
-	}
-
-	private native void getComm(int type);
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * <p>It is recommended to use {@link #dup} instead of {@link #clone}
-	 * because the last can't throw an {@link mpi.MPIException}.
-	 * @return copy of this communicator
-	 */
-	@Override public Comm clone()
-	{
-		try
-		{
-			return dup();
-		}
-		catch(MPIException e)
-		{
-			throw new RuntimeException(e.getMessage());
-		}
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Comm dup() throws MPIException
-	{
-		MPI.check();
-		return new Comm(dup(handle));
-	}
-
-	protected final native long dup(long comm) throws MPIException;
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_IDUP}.
-	 * <p>The new communicator can't be used before the operation completes.
-	 * The request object must be obtained calling {@link #getRequest}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Comm iDup() throws MPIException
-	{
-		MPI.check();
-		return new Comm(iDup(handle));
-	}
-
-	protected final native long[] iDup(long comm) throws MPIException;
-
-	/**
-	 * Duplicates this communicator with the info object used in the call.
-	 * <p>Java binding of {@code MPI_COMM_DUP_WITH_INFO}.
-	 * @param info	info object to associate with the new communicator
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Comm dupWithInfo(Info info) throws MPIException
-	{
-		MPI.check();
-		return new Comm(dupWithInfo(handle, info.handle));
-	}
-
-	protected final native long dupWithInfo(long comm, long info) throws MPIException;
-
-	/**
-	 * Returns the associated request to this communicator if it was
-	 * created using {@link #iDup}.
-	 * @return associated request if this communicator was created
-	 *         using {@link #iDup}, or null otherwise.
-	 */
-	public final Request getRequest()
-	{
-		return request;
-	}
-
-	/**
-	 * Size of group of this communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_SIZE}.
-	 * @return number of processors in the group of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int getSize() throws MPIException
-	{
-		MPI.check();
-		return getSize(handle);
-	}
-
-	private native int getSize(long comm) throws MPIException;
-
-	/**
-	 * Rank of this process in group of this communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_RANK}.
-	 * @return rank of the calling process in the group of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int getRank() throws MPIException
-	{
-		MPI.check();
-		return getRank(handle);
-	}
-
-	private native int getRank(long comm) throws MPIException;
-
-	/**
-	 * Compare two communicators.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_COMPARE}.
-	 * @param comm1 first communicator
-	 * @param comm2 second communicator
-	 * @return
-	 * {@code MPI.IDENT} results if the {@code comm1} and {@code comm2}
-	 * are references to the same object (ie, if {@code comm1 == comm2}).<br>
-	 * {@code MPI.CONGRUENT} results if the underlying groups are identical
-	 * but the communicators differ by context.<br>
-	 * {@code MPI.SIMILAR} results if the underlying groups are similar
-	 * but the communicators differ by context.<br>
-	 * {@code MPI.UNEQUAL} results otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int compare(Comm comm1, Comm comm2) throws MPIException
-	{
-		MPI.check();
-		return compare(comm1.handle, comm2.handle);
-	}
-
-	private static native int compare(long comm1, long comm2) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_COMM_FREE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override final public void free() throws MPIException
-	{
-		MPI.check();
-		handle = free(handle);
-	}
-
-	private native long free(long comm) throws MPIException;
-
-	/**
-	 * Test if communicator object is null (has been freed).
-	 * Java binding of {@code MPI_COMM_NULL}.
-	 * @return true if the comm object is null, false otherwise
-	 */
-	public final boolean isNull()
-	{
-		return handle == nullHandle;
-	}
-
-	/**
-	 * Java binding of {@code MPI_COMM_SET_INFO}.
-	 * @param info info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void setInfo(Info info) throws MPIException
-	{
-		MPI.check();
-		setInfo(handle, info.handle);
-	}
-
-	private native void setInfo(long comm, long info) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_COMM_GET_INFO}.
-	 * @return new info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Info getInfo() throws MPIException
-	{
-		MPI.check();
-		return new Info(getInfo(handle));
-	}
-
-	private native long getInfo(long comm) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_COMM_DISCONNECT}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void disconnect() throws MPIException
-	{
-		MPI.check();
-		handle = disconnect(handle);
-	}
-
-	private native long disconnect(long comm) throws MPIException;
-
-	/**
-	 * Return group associated with a communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_GROUP}.
-	 * @return group corresponding to this communicator group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Group getGroup() throws MPIException
-	{
-		MPI.check();
-		return new Group(getGroup(handle));
-	}
-
-	private native long getGroup(long comm);
-
-	// Inter-communication
-
-	/**
-	 * Test if this communicator is an inter-communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_TEST_INTER}.
-	 * @return {@code true} if this is an inter-communicator,
-	 *         {@code false} otherwise
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final boolean isInter() throws MPIException
-	{
-		MPI.check();
-		return isInter(handle);
-	}
-
-	private native boolean isInter(long comm) throws MPIException;
-
-	/**
-	 * Create an inter-communicator.
-	 * <p>
-	 * Java binding of the MPI operation {@code MPI_INTERCOMM_CREATE}.
-	 * <p>
-	 * This operation is defined as a method on the "peer communicator",
-	 * making it analogous to a {@code send} or {@code recv} communication
-	 * with the remote group leader.
-	 * @param localComm    local intra-communicator
-	 * @param localLeader  rank of local group leader in {@code localComm}
-	 * @param remoteLeader rank of remote group leader in this communicator
-	 * @param tag          "safe" tag
-	 * @return new inter-communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intercomm createIntercomm(Comm localComm, int localLeader,
-			int remoteLeader, int tag)
-					throws MPIException
-	{
-		MPI.check();
-
-		return new Intercomm(createIntercomm(handle, localComm.handle,
-				localLeader, remoteLeader, tag));
-	}
-
-	private native long createIntercomm(
-			long comm, long localComm, int localLeader,
-			int remoteLeader, int tag) throws MPIException;
-
-	// Blocking Send and Recv
-
-	/**
-	 * Blocking send operation.
-	 * <p>Java binding of the MPI operation {@code MPI_SEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void send(Object buf, int count, Datatype type, int dest, int tag)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		send(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
-	}
-
-	private native void send(
-			long comm, Object buf, boolean db, int offset, int count,
-			long type, int baseType, int dest, int tag) throws MPIException;
-
-	/**
-	 * Blocking receive operation.
-	 * <p>Java binding of the MPI operation {@code MPI_RECV}.
-	 * @param buf    receive buffer
-	 * @param count  number of items in receive buffer
-	 * @param type   datatype of each item in receive buffer
-	 * @param source rank of source
-	 * @param tag    message tag
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Status recv(Object buf, int count,
-			Datatype type, int source, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		Status status = new Status();
-
-		recv(handle, buf, db, off, count,
-				type.handle, type.baseType, source, tag, status.data);
-
-		return status;
-	}
-
-	private native void recv(
-			long comm, Object buf, boolean db, int offset, int count,
-			long type, int basetype, int source, int tag, long[] stat)
-					throws MPIException;
-
-	// Send-Recv
-
-	/**
-	 * Execute a blocking send and receive operation.
-	 * <p>Java binding of the MPI operation {@code MPI_SENDRECV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param dest      rank of destination
-	 * @param sendtag   send tag
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items in receive buffer
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param source    rank of source
-	 * @param recvtag   receive tag
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 * @see mpi.Comm#recv(Object, int, Datatype, int, int)
-	 */
-	public final Status sendRecv(
-			Object sendbuf, int sendcount, Datatype sendtype, int dest,   int sendtag,
-			Object recvbuf, int recvcount, Datatype recvtype, int source, int recvtag)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		Status status = new Status();
-
-		sendRecv(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType, dest, sendtag,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType, source, recvtag, status.data);
-
-		return status;
-	}
-
-	private native void sendRecv(
-			long comm, Object sbuf, boolean sdb, int soffset, int scount,
-			long sType, int sBaseType, int dest, int stag,
-			Object rbuf, boolean rdb, int roffset, int rcount,
-			long rType, int rBaseType, int source, int rtag,
-			long[] stat) throws MPIException;
-
-	/**
-	 * Execute a blocking send and receive operation,
-	 * receiving message into send buffer.
-	 * <p>Java binding of the MPI operation {@code MPI_SENDRECV_REPLACE}.
-	 * @param buf     buffer
-	 * @param count   number of items to send
-	 * @param type    datatype of each item in buffer
-	 * @param dest    rank of destination
-	 * @param sendtag send tag
-	 * @param source  rank of source
-	 * @param recvtag receive tag
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 * @see mpi.Comm#recv(Object, int, Datatype, int, int)
-	 */
-	public final Status sendRecvReplace(
-			Object buf, int count, Datatype type,
-			int dest, int sendtag, int source, int recvtag)
-					throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		Status status = new Status();
-
-		sendRecvReplace(handle, buf, db, off, count, type.handle, type.baseType,
-				dest, sendtag, source, recvtag, status.data);
-
-		return status;
-	}
-
-	private native void sendRecvReplace(
-			long comm, Object buf, boolean db, int offset, int count,
-			long type, int baseType, int dest, int stag,
-			int source, int rtag, long[] stat) throws MPIException;
-
-	// Communication Modes
-
-	/**
-	 * Send in buffered mode.
-	 * <p>Java binding of the MPI operation {@code MPI_BSEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final void bSend(Object buf, int count, Datatype type, int dest, int tag)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		bSend(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
-	}
-
-	private native void bSend(
-			long comm, Object buf, boolean db, int offset, int count,
-			long type, int baseType, int dest, int tag) throws MPIException;
-
-	/**
-	 * Send in synchronous mode.
-	 * <p>Java binding of the MPI operation {@code MPI_SSEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final void sSend(Object buf, int count, Datatype type, int dest, int tag)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		sSend(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
-	}
-
-	private native void sSend(
-			long comm, Object buf, boolean db, int offset, int count,
-			long type, int baseType, int dest, int tag) throws MPIException;
-
-	/**
-	 * Send in ready mode.
-	 * <p>Java binding of the MPI operation {@code MPI_RSEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final void rSend(Object buf, int count, Datatype type, int dest, int tag)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		rSend(handle, buf, db, off, count, type.handle, type.baseType, dest, tag);
-	}
-
-	private native void rSend(
-			long comm, Object buf, boolean db, int offset, int count,
-			long type, int baseType, int dest, int tag) throws MPIException;
-
-	// Nonblocking communication
-
-	/**
-	 * Start a standard mode, nonblocking send.
-	 * <p>Java binding of the MPI operation {@code MPI_ISEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Request iSend(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iSend(handle, buf, count, type.handle, dest, tag));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iSend(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Start a buffered mode, nonblocking send.
-	 * <p>Java binding of the MPI operation {@code MPI_IBSEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Request ibSend(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(ibSend(handle, buf, count, type.handle, dest, tag));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long ibSend(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Start a synchronous mode, nonblocking send.
-	 * <p>Java binding of the MPI operation {@code MPI_ISSEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Request isSend(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(isSend(handle, buf, count, type.handle, dest, tag));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long isSend(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Start a ready mode, nonblocking send.
-	 * <p>Java binding of the MPI operation {@code MPI_IRSEND}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Request irSend(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(irSend(handle, buf, count, type.handle, dest, tag));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long irSend(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Start a nonblocking receive.
-	 * <p>Java binding of the MPI operation {@code MPI_IRECV}.
-	 * @param buf    receive buffer
-	 * @param count  number of items in receive buffer
-	 * @param type   datatype of each item in receive buffer
-	 * @param source rank of source
-	 * @param tag    message tag
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#recv(Object, int, Datatype, int, int)
-	 */
-	public final Request iRecv(Buffer buf, int count,
-			Datatype type, int source, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iRecv(handle, buf, count, type.handle, source, tag));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iRecv(
-			long comm, Buffer buf, int count, long type, int source, int tag)
-					throws MPIException;
-
-
-	// Persistent communication  requests
-
-	/**
-	 * Creates a persistent communication request for a standard mode send.
-	 * <p>Java binding of the MPI operation {@code MPI_SEND_INIT}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return persistent communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Prequest sendInit(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Prequest preq = new Prequest(sendInit(handle, buf, count, type.handle, dest, tag));
-		preq.addSendBufRef(buf);
-		return preq;
-	}
-
-	private native long sendInit(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Creates a persistent communication request for a buffered mode send.
-	 * <p>Java binding of the MPI operation {@code MPI_BSEND_INIT}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return persistent communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Prequest bSendInit(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Prequest preq = new Prequest(bSendInit(handle, buf, count, type.handle, dest, tag));
-		preq.addSendBufRef(buf);
-		return preq;
-	}
-
-	private native long bSendInit(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Creates a persistent communication request for a synchronous mode send.
-	 * <p>Java binding of the MPI operation {@code MPI_SSEND_INIT}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return persistent communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Prequest sSendInit(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Prequest preq = new Prequest(sSendInit(handle, buf, count, type.handle, dest, tag));
-		preq.addSendBufRef(buf);
-		return preq;
-	}
-
-	private native long sSendInit(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Creates a persistent communication request for a ready mode send.
-	 * <p>Java binding of the MPI operation {@code MPI_RSEND_INIT}.
-	 * @param buf   send buffer
-	 * @param count number of items to send
-	 * @param type  datatype of each item in send buffer
-	 * @param dest  rank of destination
-	 * @param tag   message tag
-	 * @return persistent communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#send(Object, int, Datatype, int, int)
-	 */
-	public final Prequest rSendInit(Buffer buf, int count,
-			Datatype type, int dest, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Prequest preq = new Prequest(rSendInit(handle, buf, count, type.handle, dest, tag));
-		preq.addSendBufRef(buf);
-		return preq;
-	}
-
-	private native long rSendInit(
-			long comm, Buffer buf, int count, long type, int dest, int tag)
-					throws MPIException;
-
-	/**
-	 * Creates a persistent communication request for a receive operation.
-	 * <p>Java binding of the MPI operation {@code MPI_RECV_INIT}.
-	 * @param buf    receive buffer
-	 * @param count  number of items in receive buffer
-	 * @param type   datatype of each item in receive buffer
-	 * @param source rank of source
-	 * @param tag    message tag
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 * @see mpi.Comm#recv(Object, int, Datatype, int, int)
-	 */
-	public final Prequest recvInit(Buffer buf, int count,
-			Datatype type, int source, int tag)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Prequest preq = new Prequest(recvInit(handle, buf, count, type.handle, source, tag));
-		preq.addRecvBufRef(buf);
-		return preq;
-	}
-
-	private native long recvInit(
-			long comm, Buffer buf, int count, long type, int source, int tag)
-					throws MPIException;
-
-	// Pack and Unpack
-
-	/**
-	 * Packs message in send buffer {@code inbuf} into space specified in
-	 * {@code outbuf}.
-	 * <p>
-	 * Java binding of the MPI operation {@code MPI_PACK}.
-	 * <p>
-	 * The return value is the output value of {@code position} - the
-	 * initial value incremented by the number of bytes written.
-	 * @param inbuf    input buffer
-	 * @param incount  number of items in input buffer
-	 * @param type     datatype of each item in input buffer
-	 * @param outbuf   output buffer
-	 * @param position initial position in output buffer
-	 * @return final position in output buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int pack(Object inbuf, int incount, Datatype type,
-			byte[] outbuf, int position)
-					throws MPIException
-	{
-		MPI.check();
-		int offset = 0;
-		boolean indb = false;
-
-		if(inbuf instanceof Buffer && !(indb = ((Buffer)inbuf).isDirect()))
-		{
-			offset = type.getOffset(inbuf);
-			inbuf  = ((Buffer)inbuf).array();
-		}
-
-		return pack(handle, inbuf, indb, offset, incount,
-				type.handle, outbuf, position);
-	}
-
-	private native int pack(
-			long comm, Object inbuf, boolean indb, int offset, int incount,
-			long type, byte[] outbuf, int position) throws MPIException;
-
-	/**
-	 * Unpacks message in receive buffer {@code outbuf} into space specified in
-	 * {@code inbuf}.
-	 * <p>
-	 * Java binding of the MPI operation {@code MPI_UNPACK}.
-	 * <p>
-	 * The return value is the output value of {@code position} - the
-	 * initial value incremented by the number of bytes read.
-	 * @param inbuf    input buffer
-	 * @param position initial position in input buffer
-	 * @param outbuf   output buffer
-	 * @param outcount number of items in output buffer
-	 * @param type     datatype of each item in output buffer
-	 * @return final position in input buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int unpack(byte[] inbuf, int position,
-			Object outbuf, int outcount, Datatype type)
-					throws MPIException
-	{
-		MPI.check();
-		int offset = 0;
-		boolean outdb = false;
-
-		if(outbuf instanceof Buffer && !(outdb = ((Buffer)outbuf).isDirect()))
-		{
-			offset = type.getOffset(outbuf);
-			outbuf = ((Buffer)outbuf).array();
-		}
-
-		return unpack(handle, inbuf, position, outbuf, outdb,
-				offset, outcount, type.handle);
-	}
-
-	private native int unpack(
-			long comm, byte[] inbuf, int position, Object outbuf, boolean outdb,
-			int offset, int outcount, long type) throws MPIException;
-
-	/**
-	 * Returns an upper bound on the increment of {@code position} effected
-	 * by {@code pack}.
-	 * <p>Java binding of the MPI operation {@code MPI_PACK_SIZE}.
-	 * @param incount number of items in input buffer
-	 * @param type    datatype of each item in input buffer
-	 * @return upper bound on size of packed message
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int packSize(int incount, Datatype type) throws MPIException
-	{
-		MPI.check();
-		return packSize(handle, incount, type.handle);
-	}
-
-	private native int packSize(long comm, int incount, long type)
-			throws MPIException;
-
-	// Probe and Cancel
-
-	/**
-	 * Check if there is an incoming message matching the pattern specified.
-	 * <p>Java binding of the MPI operation {@code MPI_IPROBE}.
-	 * <p>If such a message is currently available, a status object similar
-	 * to the return value of a matching {@code recv} operation is returned.
-	 * @param source rank of source
-	 * @param tag    message tag
-	 * @return status object if such a message is currently available,
-	 *         {@code null} otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Status iProbe(int source, int tag) throws MPIException
-	{
-		MPI.check();
-		return iProbe(handle, source, tag);
-	}
-
-	private native Status iProbe(long comm, int source, int tag)
-			throws MPIException;
-
-	/**
-	 * Wait until there is an incoming message matching the pattern specified.
-	 * <p>Java binding of the MPI operation {@code MPI_PROBE}.
-	 * <p>Returns a status object similar to the return value of a matching
-	 * {@code recv} operation.
-	 * @param source rank of source
-	 * @param tag    message tag
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Status probe(int source, int tag) throws MPIException
-	{
-		MPI.check();
-		Status status = new Status();
-		probe(handle, source, tag, status.data);
-		return status;
-	}
-
-	private native void probe(long comm, int source, int tag, long[] stat)
-			throws MPIException;
-
-	// Caching
-
-	/**
-	 * Create a new attribute key.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_CREATE_KEYVAL}.
-	 * @return attribute key for future access
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int createKeyval() throws MPIException
-	{
-		MPI.check();
-		return createKeyval_jni();
-	}
-
-	private static native int createKeyval_jni() throws MPIException;
-
-	/**
-	 * Frees an attribute key for communicators.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_FREE_KEYVAL}.
-	 * @param keyval attribute key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void freeKeyval(int keyval) throws MPIException
-	{
-		MPI.check();
-		freeKeyval_jni(keyval);
-	}
-
-	private static native void freeKeyval_jni(int keyval) throws MPIException;
-
-	/**
-	 * Stores attribute value associated with a key.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_SET_ATTR}.
-	 * @param keyval attribute key
-	 * @param value  attribute value
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void setAttr(int keyval, Object value) throws MPIException
-	{
-		MPI.check();
-		setAttr(handle, keyval, MPI.attrSet(value));
-	}
-
-	private native void setAttr(long comm, int keyval, byte[] value)
-			throws MPIException;
-
-	/**
-	 * Retrieves attribute value by key.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_GET_ATTR}.
-	 * @param keyval attribute key
-	 * @return attribute value or null if no attribute is associated with the key.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Object getAttr(int keyval) throws MPIException
-	{
-		MPI.check();
-
-		if( keyval == MPI.TAG_UB       ||
-				keyval == MPI.HOST         ||
-				keyval == MPI.IO           ||
-				keyval == MPI.APPNUM       ||
-				keyval == MPI.LASTUSEDCODE ||
-				keyval == MPI.UNIVERSE_SIZE)
-		{
-			return getAttr_predefined(handle, keyval);
-		}
-		else if(keyval == MPI.WTIME_IS_GLOBAL)
-		{
-			Integer value = (Integer)getAttr_predefined(handle, keyval);
-			return value==null ? null : value.intValue() != 0;
-		}
-		else
-		{
-			return MPI.attrGet(getAttr(handle, keyval));
-		}
-	}
-
-	private native Object getAttr_predefined(long comm, int keyval)
-			throws MPIException;
-
-	private native byte[] getAttr(long comm, int keyval) throws MPIException;
-
-	/**
-	 * Deletes an attribute value associated with a key on a communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_DELETE_ATTR}.
-	 * @param keyval attribute key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void deleteAttr(int keyval) throws MPIException
-	{
-		MPI.check();
-		deleteAttr(handle, keyval);
-	}
-
-	private native void deleteAttr(long comm, int keyval) throws MPIException;
-
-	// Process Topologies
-
-	/**
-	 * Returns the type of topology associated with the communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_TOPO_TEST}.
-	 * <p>The return value will be one of {@code MPI.GRAPH}, {@code MPI.CART},
-	 * {@code MPI.DIST_GRAPH} or {@code MPI.UNDEFINED}.
-	 * @return topology type of communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int getTopology() throws MPIException
-	{
-		MPI.check();
-		return getTopology(handle);
-	}
-
-	private native int getTopology(long comm) throws MPIException;
-
-	// Environmental Management
-
-	/**
-	 * Abort MPI.
-	 * <p>Java binding of the MPI operation {@code MPI_ABORT}.
-	 * @param errorcode error code for Unix or POSIX environments
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void abort(int errorcode) throws MPIException
-	{
-		MPI.check();
-		abort(handle, errorcode);
-	}
-
-	private native void abort(long comm, int errorcode) throws MPIException;
-
-	// Error handler
-
-	/**
-	 * Associates a new error handler with communicator at the calling process.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_SET_ERRHANDLER}.
-	 * @param errhandler new MPI error handler for communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void setErrhandler(Errhandler errhandler) throws MPIException
-	{
-		MPI.check();
-		setErrhandler(handle, errhandler.handle);
-	}
-
-	private native void setErrhandler(long comm, long errhandler)
-			throws MPIException;
-
-	/**
-	 * Returns the error handler currently associated with the communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_GET_ERRHANDLER}.
-	 * @return MPI error handler currently associated with communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Errhandler getErrhandler() throws MPIException
-	{
-		MPI.check();
-		return new Errhandler(getErrhandler(handle));
-	}
-
-	private native long getErrhandler(long comm);
-
-	/**
-	 * Calls the error handler currently associated with the communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_CALL_ERRHANDLER}.
-	 * @param errorCode error code
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void callErrhandler(int errorCode) throws MPIException
-	{
-		callErrhandler(handle, errorCode);
-	}
-
-	private native void callErrhandler(long handle, int errorCode)
-			throws MPIException;
-
-	// Collective Communication
-
-	/**
-	 * A call to {@code barrier} blocks the caller until all process
-	 * in the group have called it.
-	 * <p>Java binding of the MPI operation {@code MPI_BARRIER}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void barrier() throws MPIException
-	{
-		MPI.check();
-		barrier(handle);
-	}
-
-	private native void barrier(long comm) throws MPIException;
-
-	/**
-	 * Nonblocking barrier synchronization.
-	 * <p>Java binding of the MPI operation {@code MPI_IBARRIER}.
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iBarrier() throws MPIException
-	{
-		MPI.check();
-		return new Request(iBarrier(handle));
-	}
-
-	private native long iBarrier(long comm) throws MPIException;
-
-	/**
-	 * Broadcast a message from the process with rank {@code root}
-	 * to all processes of the group.
-	 * <p>Java binding of the MPI operation {@code MPI_BCAST}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each item in buffer
-	 * @param root  rank of broadcast root
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void bcast(Object buf, int count, Datatype type, int root)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		bcast(handle, buf, db, off, count, type.handle, type.baseType, root);
-	}
-
-	private native void bcast(
-			long comm, Object buf, boolean db, int offset, int count,
-			long type, int basetype, int root) throws MPIException;
-
-	/**
-	 * Broadcast a message from the process with rank {@code root}
-	 * to all processes of the group.
-	 * <p>Java binding of the MPI operation {@code MPI_IBCAST}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each item in buffer
-	 * @param root  rank of broadcast root
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iBcast(Buffer buf, int count, Datatype type, int root)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iBcast(handle, buf, count, type.handle, root));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iBcast(
-			long comm, Buffer buf, int count, long type, int root)
-					throws MPIException;
-
-	/**
-	 * Each process sends the contents of its send buffer to the root process.
-	 * <p>Java binding of the MPI operation {@code MPI_GATHER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of receiving process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void gather(
-			Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int recvcount, Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		gather(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType, root);
-	}
-
-	/**
-	 * Each process sends the contents of its send buffer to the root process.
-	 * <p>Java binding of the MPI operation {@code MPI_GATHER}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * The buffer is used by the root process to receive data,
-	 * and it is used by the non-root processes to send data.
-	 * @param buf   buffer
-	 * @param count number of items to send/receive
-	 * @param type  datatype of each item in buffer
-	 * @param root  rank of receiving process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void gather(Object buf, int count, Datatype type, int root)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		gather(handle, null, false, 0, 0, 0, 0,
-				buf, db, off, count, type.handle, type.baseType, root);
-	}
-
-	private native void gather(
-			long comm, Object sendBuf, boolean sdb, int sendOff, int sendCount,
-			long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOff, int recvCount,
-			long recvType, int recvBaseType, int root)
-					throws MPIException;
-
-	/**
-	 * Each process sends the contents of its send buffer to the root process.
-	 * <p>Java binding of the MPI operation {@code MPI_IGATHER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of receiving process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iGather(
-			Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int recvcount, Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iGather(handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, recvtype.handle, root));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Each process sends the contents of its send buffer to the root process.
-	 * <p>Java binding of the MPI operation {@code MPI_IGATHER}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * The buffer is used by the root process to receive data,
-	 * and it is used by the non-root processes to send data.
-	 * @param buf   buffer
-	 * @param count number of items to send/receive
-	 * @param type  datatype of each item in buffer
-	 * @param root  rank of receiving process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iGather(Buffer buf, int count, Datatype type, int root)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iGather(handle, null, 0, 0,
-				buf, count, type.handle, root));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iGather(
-			long comm, Buffer sendbuf, int sendcount, long sendtype,
-			Buffer recvbuf, int recvcount, long recvtype,
-			int root) throws MPIException;
-
-	/**
-	 * Extends functionality of {@code gather} by allowing varying
-	 * counts of data from each process.
-	 * <p>Java binding of the MPI operation {@code MPI_GATHERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of receiving process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void gatherv(Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int[] recvcount, int[] displs,
-			Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		gatherv(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount, displs,
-				recvtype.handle, recvtype.baseType, root);
-	}
-
-	/**
-	 * Extends functionality of {@code gather} by allowing varying
-	 * counts of data from each process.
-	 * <p>Java binding of the MPI operation {@code MPI_GATHERV} using
-	 * {@code MPI_IN_PLACE} instead of the send buffer in the root process.
-	 * This method must be used in the root process.
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of receiving process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void gatherv(Object recvbuf, int[] recvcount, int[] displs,
-			Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		int recvoff = 0;
-		boolean rdb = false;
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		gatherv(handle, null, false, 0, 0, 0, 0, recvbuf, rdb, recvoff, recvcount,
-				displs, recvtype.handle, recvtype.baseType, root);
-	}
-
-	/**
-	 * Extends functionality of {@code gather} by allowing varying
-	 * counts of data from each process.
-	 * <p>Java binding of the MPI operation {@code MPI_GATHERV} using
-	 * {@code MPI_IN_PLACE} instead of the send buffer in the root process.
-	 * This method must be used in the non-root processes.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param root      rank of receiving process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void gatherv(Object sendbuf, int sendcount,
-			Datatype sendtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		int sendoff = 0;
-		boolean sdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		gatherv(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				null, false, 0, null, null, 0, 0, root);
-	}
-
-	private native void gatherv(
-			long comm, Object sendBuf, boolean sdb, int sendOffset,
-			int sendCount, long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset,
-			int[] recvCount, int[] displs, long recvType, int recvBaseType,
-			int root) throws MPIException;
-
-	/**
-	 * Extends functionality of {@code gather} by allowing varying
-	 * counts of data from each process.
-	 * <p>Java binding of the MPI operation {@code MPI_IGATHERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of receiving process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iGatherv(
-			Buffer sendbuf, int sendcount, Datatype sendtype, Buffer recvbuf,
-			int[] recvcount, int[] displs, Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iGatherv(
-				handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, displs, recvtype.handle, root));
-		req.addSendBufRef(sendbuf);
-		return req;
-	}
-
-	/**
-	 * Extends functionality of {@code gather} by allowing varying
-	 * counts of data from each process.
-	 * <p>Java binding of the MPI operation {@code MPI_IGATHERV} using
-	 * {@code MPI_IN_PLACE} instead of the send buffer in the root process.
-	 * This method must be used in the root process.
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of receiving process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iGatherv(Buffer recvbuf, int[] recvcount, int[] displs,
-			Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(recvbuf);
-		Request req = new Request(iGatherv(handle, null, 0, 0,
-				recvbuf, recvcount, displs, recvtype.handle, root));
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Extends functionality of {@code gather} by allowing varying
-	 * counts of data from each process.
-	 * <p>Java binding of the MPI operation {@code MPI_IGATHERV} using
-	 * {@code MPI_IN_PLACE} instead of the send buffer in the root process.
-	 * This method must be used in the non-root processes.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param root      rank of receiving process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iGatherv(Buffer sendbuf, int sendcount,
-			Datatype sendtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf);
-		Request req = new Request(iGatherv(handle, sendbuf, sendcount, sendtype.handle,
-				null, null, null, 0, root));
-		req.addSendBufRef(sendbuf);
-		return req;
-	}
-
-	private native long iGatherv(
-			long handle, Buffer sendbuf, int sendcount, long sendtype,
-			Buffer recvbuf, int[] recvcount, int[] displs,
-			long recvtype, int root)
-					throws MPIException;
-
-	/**
-	 * Inverse of the operation {@code gather}.
-	 * <p>Java binding of the MPI operation {@code MPI_SCATTER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of sending process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void scatter(
-			Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int recvcount, Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		scatter(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType, root);
-	}
-
-	/**
-	 * Inverse of the operation {@code gather}.
-	 * <p>Java binding of the MPI operation {@code MPI_SCATTER}
-	 * using {@code MPI_IN_PLACE} instead of the receive buffer.
-	 * The buffer is used by the root process to send data,
-	 * and it is used by the non-root processes to receive data.
-	 * @param buf   send/receive buffer
-	 * @param count number of items to send/receive
-	 * @param type  datatype of each item in buffer
-	 * @param root  rank of sending process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void scatter(Object buf, int count, Datatype type, int root)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		scatter(handle, buf, db, off, count, type.handle, type.baseType,
-				null, false, 0, 0, 0, 0, root);
-	}
-
-	private native void scatter(
-			long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
-			long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset, int recvCount,
-			long recvType, int recvBaseType, int root) throws MPIException;
-
-	/**
-	 * Inverse of the operation {@code gather}.
-	 * <p>Java binding of the MPI operation {@code MPI_ISCATTER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of sending process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iScatter(
-			Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int recvcount, Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iScatter(handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, recvtype.handle, root));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Inverse of the operation {@code gather}.
-	 * <p>Java binding of the MPI operation {@code MPI_ISCATTER}
-	 * using {@code MPI_IN_PLACE} instead of the receive buffer.
-	 * The buffer is used by the root process to send data,
-	 * and it is used by the non-root processes to receive data.
-	 * @param buf   send/receive buffer
-	 * @param count number of items to send/receive
-	 * @param type  datatype of each item in buffer
-	 * @param root  rank of sending process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iScatter(Buffer buf, int count, Datatype type, int root)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iScatter(handle, buf, count, type.handle,
-				null, 0, 0, root));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iScatter(
-			long comm, Buffer sendbuf, int sendcount, long sendtype,
-			Buffer recvbuf, int recvcount, long recvtype, int root)
-					throws MPIException;
-
-	/**
-	 * Inverse of the operation {@code gatherv}.
-	 * <p>Java binding of the MPI operation {@code MPI_SCATTERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each process
-	 * @param displs    displacements from which to take outgoing data
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of sending process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void scatterv(
-			Object sendbuf, int[] sendcount, int[] displs, Datatype sendtype,
-			Object recvbuf, int recvcount, Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		scatterv(handle, sendbuf, sdb, sendoff, sendcount, displs,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType, root);
-	}
-
-	/**
-	 * Inverse of the operation {@code gatherv}.
-	 * <p>Java binding of the MPI operation {@code MPI_SCATTERV} using
-	 * {@code MPI_IN_PLACE} instead of the receive buffer in the root process.
-	 * This method must be used in the root process.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each process
-	 * @param displs    displacements from which to take outgoing data
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param root      rank of sending process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void scatterv(Object sendbuf, int[] sendcount, int[] displs,
-			Datatype sendtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		int sendoff = 0;
-		boolean sdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		scatterv(handle, sendbuf, sdb, sendoff, sendcount, displs,
-				sendtype.handle, sendtype.baseType,
-				null, false, 0, 0, 0, 0, root);
-	}
-
-	/**
-	 * Inverse of the operation {@code gatherv}.
-	 * <p>Java binding of the MPI operation {@code MPI_SCATTERV} using
-	 * {@code MPI_IN_PLACE} instead of the receive buffer in the root process.
-	 * This method must be used in the non-root processes.
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of sending process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void scatterv(Object recvbuf, int recvcount,
-			Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		int recvoff = 0;
-		boolean rdb = false;
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		scatterv(handle, null, false, 0, null, null, 0, 0,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType, root);
-	}
-
-	private native void scatterv(
-			long comm, Object sendBuf, boolean sdb, int sendOffset,
-			int[] sendCount, int[] displs, long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset, int recvCount,
-			long recvType, int recvBaseType, int root)
-					throws MPIException;
-
-	/**
-	 * Inverse of the operation {@code gatherv}.
-	 * <p>Java binding of the MPI operation {@code MPI_ISCATTERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each process
-	 * @param displs    displacements from which to take outgoing data
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of sending process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iScatterv(
-			Buffer sendbuf, int[] sendcount, int[] displs,  Datatype sendtype,
-			Buffer recvbuf, int recvcount, Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iScatterv(
-				handle, sendbuf, sendcount, displs, sendtype.handle,
-				recvbuf, recvcount, recvtype.handle, root));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Inverse of the operation {@code gatherv}.
-	 * <p>Java binding of the MPI operation {@code MPI_ISCATTERV} using
-	 * {@code MPI_IN_PLACE} instead of the receive buffer in the root process.
-	 * This method must be used in the root process.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each process
-	 * @param displs    displacements from which to take outgoing data
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param root      rank of sending process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iScatterv(Buffer sendbuf, int[] sendcount, int[] displs,
-			Datatype sendtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf);
-		Request req = new Request(iScatterv(handle, sendbuf, sendcount, displs,
-				sendtype.handle, null, 0, 0, root));
-		req.addSendBufRef(sendbuf);
-		return req;
-	}
-
-	/**
-	 * Inverse of the operation {@code gatherv}.
-	 * <p>Java binding of the MPI operation {@code MPI_ISCATTERV} using
-	 * {@code MPI_IN_PLACE} instead of the receive buffer in the root process.
-	 * This method must be used in the non-root processes.
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @param root      rank of sending process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iScatterv(Buffer recvbuf, int recvcount,
-			Datatype recvtype, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(recvbuf);
-		Request req = new Request(iScatterv(handle, null, null, null, 0,
-				recvbuf, recvcount, recvtype.handle, root));
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	private native long iScatterv(
-			long comm, Buffer sendbuf, int[] sendcount, int[] displs, long sendtype,
-			Buffer recvbuf, int recvcount, long recvtype, int root)
-					throws MPIException;
-
-	/**
-	 * Similar to {@code gather}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLGATHER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allGather(Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		allGather(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	/**
-	 * Similar to {@code gather}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLGATHER}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer
-	 * @param count number of items to receive
-	 * @param type  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allGather(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		allGather(handle, null, false, 0, 0, 0, 0,
-				buf, db, off, count, type.handle, type.baseType);
-	}
-
-	private native void allGather(
-			long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
-			long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset, int recvCount,
-			long recvType, int recvBaseType) throws MPIException;
-
-	/**
-	 * Similar to {@code gather}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLGATHER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllGather(
-			Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iAllGather(handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Similar to {@code gather}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLGATHER}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer
-	 * @param count number of items to receive
-	 * @param type  datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllGather(Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iAllGather(handle, null, 0, 0, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iAllGather(
-			long comm, Buffer sendbuf, int sendcount, long sendtype,
-			Buffer recvbuf, int recvcount, long recvtype) throws MPIException;
-
-	/**
-	 * Similar to {@code gatherv}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLGATHERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allGatherv(
-			Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int[] recvcount, int[] displs, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		allGatherv(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount, displs,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	/**
-	 * Similar to {@code gatherv}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLGATHERV}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allGatherv(Object recvbuf, int[] recvcount,
-			int[] displs, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		int recvoff = 0;
-		boolean rdb = false;
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		allGatherv(handle, null, false, 0, 0, 0, 0,
-				recvbuf, rdb, recvoff, recvcount,
-				displs, recvtype.handle, recvtype.baseType);
-	}
-
-	private native void allGatherv(
-			long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
-			long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset, int[] recvCount,
-			int[] displs, long recvType, int recvBasetype) throws MPIException;
-
-	/**
-	 * Similar to {@code gatherv}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLGATHERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllGatherv(
-			Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int[] recvcount, int[] displs, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iAllGatherv(
-				handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, displs, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Similar to {@code gatherv}, but all processes receive the result.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLGATHERV}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf    receive buffer
-	 * @param count  number of elements received from each process
-	 * @param displs displacements at which to place incoming data
-	 * @param type   datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllGatherv(
-			Buffer buf, int[] count, int[] displs, Datatype type)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iAllGatherv(
-				handle, null, 0, 0, buf, count, displs, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iAllGatherv(
-			long handle, Buffer sendbuf, int sendcount, long sendtype,
-			Buffer recvbuf, int[] recvcount, int[] displs, long recvtype)
-					throws MPIException;
-
-	/**
-	 * Extension of {@code allGather} to the case where each process sends
-	 * distinct data to each of the receivers.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLTOALL}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each process
-	 * @param sendtype  datatype send buffer items
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items received from any process
-	 * @param recvtype  datatype of receive buffer items
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allToAll(Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		allToAll(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	private native void allToAll(
-			long comm, Object sendBuf, boolean sdb, int sendOffset, int sendCount,
-			long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset, int recvCount,
-			long recvType, int recvBaseType) throws MPIException;
-
-	/**
-	 * Extension of {@code allGather} to the case where each process sends
-	 * distinct data to each of the receivers.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLTOALL}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each process
-	 * @param sendtype  datatype send buffer items
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items received from any process
-	 * @param recvtype  datatype of receive buffer items
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllToAll(Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iAllToAll(handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	private native long iAllToAll(
-			long comm, Buffer sendbuf, int sendcount, long sendtype,
-			Buffer recvbuf, int recvcount, long recvtype) throws MPIException;
-
-	/**
-	 * Adds flexibility to {@code allToAll}: location of data for send is
-	 * specified by {@code sdispls} and location to place data on receive
-	 * side is specified by {@code rdispls}.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLTOALLV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each buffer
-	 * @param sdispls   displacements from which to take outgoing data
-	 * @param sendtype  datatype send buffer items
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param rdispls   displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allToAllv(
-			Object sendbuf, int[] sendcount, int[] sdispls, Datatype sendtype,
-			Object recvbuf, int[] recvcount, int[] rdispls, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		allToAllv(handle, sendbuf, sdb, sendoff, sendcount, sdispls,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount, rdispls,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	private native void allToAllv(
-			long comm, Object sendBuf, boolean sdb, int sendOffset,
-			int[] sendCount, int[] sdispls, long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset,
-			int[] recvCount, int[] rdispls, long recvType, int recvBaseType)
-					throws MPIException;
-
-	/**
-	 * Adds flexibility to {@code allToAll}: location of data for send is
-	 * specified by {@code sdispls} and location to place data on receive
-	 * side is specified by {@code rdispls}.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLTOALLV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each buffer
-	 * @param sdispls   displacements from which to take outgoing data
-	 * @param sendtype  datatype send buffer items
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param rdispls   displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllToAllv(
-			Buffer sendbuf, int[] sendcount, int[] sdispls, Datatype sendtype,
-			Buffer recvbuf, int[] recvcount, int[] rdispls, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iAllToAllv(
-				handle, sendbuf, sendcount, sdispls, sendtype.handle,
-				recvbuf, recvcount, rdispls, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	private native long iAllToAllv(long comm,
-			Buffer sendbuf, int[] sendcount, int[] sdispls, long sendtype,
-			Buffer recvbuf, int[] recvcount, int[] rdispls, long recvtype)
-					throws MPIException;
-
-	/**
-	 * Adds more flexibility to {@code allToAllv}: datatypes for send are
-	 * specified by {@code sendTypes} and datatypes for receive are specified
-	 * by {@code recvTypes} per process.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLTOALLW}.
-	 * @param sendBuf   send buffer
-	 * @param sendCount number of items sent to each buffer
-	 * @param sDispls   displacements from which to take outgoing data
-	 * @param sendTypes datatypes of send buffer items
-	 * @param recvBuf   receive buffer
-	 * @param recvCount number of elements received from each process
-	 * @param rDispls   displacements at which to place incoming data
-	 * @param recvTypes datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allToAllw(
-			Object sendBuf, int[] sendCount, int[] sDispls, Datatype[] sendTypes,
-			Object recvBuf, int[] recvCount, int[] rDispls, Datatype[] recvTypes)
-					throws MPIException
-	{
-		MPI.check();
-
-		int[] sendoffs = new int[sendTypes.length];
-		int[] recvoffs = new int[recvTypes.length];
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendBuf instanceof Buffer && !(sdb = ((Buffer)sendBuf).isDirect()))
-		{
-
-			for (int i = 0; i < sendTypes.length; i++){
-				sendoffs[i] = sendTypes[i].getOffset(sendBuf);
-			}
-			sendBuf = ((Buffer)sendBuf).array();
-		}
-
-		if(recvBuf instanceof Buffer && !(rdb = ((Buffer)recvBuf).isDirect()))
-		{
-			for (int i = 0; i < recvTypes.length; i++){
-				recvoffs[i] = recvTypes[i].getOffset(recvBuf);
-			}
-			recvBuf = ((Buffer)recvBuf).array();
-		}
-
-		long[] sendHandles = convertTypeArray(sendTypes);
-		long[] recvHandles = convertTypeArray(recvTypes);
-		int[]  sendHandles_btypes = convertTypeArrayBtype(sendTypes);
-		int[]  recvHandles_btypes = convertTypeArrayBtype(recvTypes);
-
-		allToAllw(handle, sendBuf, sdb, sendoffs, sendCount, sDispls,
-				sendHandles, sendHandles_btypes,
-				recvBuf, rdb, recvoffs, recvCount, rDispls,
-				recvHandles, recvHandles_btypes);
-	}
-
-	private native void allToAllw(long comm,
-			Object sendBuf, boolean sdb, int[] sendOffsets,
-			int[] sendCount, int[] sDispls, long[] sendTypes, int[] sendBaseTypes,
-			Object recvBuf, boolean rdb, int[] recvOffsets,
-			int[] recvCount, int[] rDispls, long[] recvTypes, int[] recvBaseTypes)
-					throws MPIException;
-
-	/**
-	 * Adds more flexibility to {@code iAllToAllv}: datatypes for send are
-	 * specified by {@code sendTypes} and datatypes for receive are specified
-	 * by {@code recvTypes} per process.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLTOALLW}.
-	 * @param sendBuf   send buffer
-	 * @param sendCount number of items sent to each buffer
-	 * @param sDispls   displacements from which to take outgoing data
-	 * @param sendTypes datatype send buffer items
-	 * @param recvBuf   receive buffer
-	 * @param recvCount number of elements received from each process
-	 * @param rDispls   displacements at which to place incoming data
-	 * @param recvTypes datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllToAllw(
-			Buffer sendBuf, int[] sendCount, int[] sDispls, Datatype[] sendTypes,
-			Buffer recvBuf, int[] recvCount, int[] rDispls, Datatype[] recvTypes)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendBuf, recvBuf);
-
-		long[] sendHandles = convertTypeArray(sendTypes);
-		long[] recvHandles = convertTypeArray(recvTypes);
-		Request req = new Request(iAllToAllw(
-				handle, sendBuf, sendCount, sDispls, sendHandles,
-				recvBuf, recvCount, rDispls, recvHandles));
-		req.addSendBufRef(sendBuf);
-		req.addRecvBufRef(recvBuf);
-		return req;
-	}
-
-	private native long iAllToAllw(long comm,
-			Buffer sendBuf, int[] sendCount, int[] sDispls, long[] sendTypes,
-			Buffer recvBuf, int[] recvCount, int[] rDispls, long[] recvTypes)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_NEIGHBOR_ALLGATHER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void neighborAllGather(
-			Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		neighborAllGather(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	private native void neighborAllGather(
-			long comm, Object sendBuf, boolean sdb, int sendOffset,
-			int sendCount, long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOffset,
-			int recvCount, long recvType, int recvBaseType)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_INEIGHBOR_ALLGATHER}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iNeighborAllGather(
-			Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iNeighborAllGather(
-				handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	private native long iNeighborAllGather(
-			long comm, Buffer sendBuf, int sendCount, long sendType,
-			Buffer recvBuf, int recvCount, long recvType)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_NEIGHBOR_ALLGATHERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements that are received from each neighbor
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of receive buffer elements
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void neighborAllGatherv(
-			Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int[] recvcount, int[] displs, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		neighborAllGatherv(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount, displs,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	private native void neighborAllGatherv(
-			long comm, Object sendBuf, boolean sdb, int sendOff,
-			int sendCount, long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOff,
-			int[] recvCount, int[] displs, long recvType, int recvBaseType);
-
-	/**
-	 * Java binding of {@code MPI_INEIGHBOR_ALLGATHERV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements that are received from each neighbor
-	 * @param displs    displacements at which to place incoming data
-	 * @param recvtype  datatype of receive buffer elements
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iNeighborAllGatherv(
-			Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int[] recvcount, int[] displs, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iNeighborAllGatherv(
-				handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, displs, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	private native long iNeighborAllGatherv(
-			long comm, Buffer sendBuf, int sendCount, long sendType,
-			Buffer recvBuf, int[] recvCount, int[] displs, long recvType)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_NEIGHBOR_ALLTOALL}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void neighborAllToAll(
-			Object sendbuf, int sendcount, Datatype sendtype,
-			Object recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		neighborAllToAll(handle, sendbuf, sdb, sendoff, sendcount,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	private native void neighborAllToAll(
-			long comm, Object sendBuf, boolean sdb, int sendOff,
-			int sendCount, long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOff,
-			int recvCount, long recvType, int recvBaseType)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_INEIGHBOR_ALLTOALL}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items to send
-	 * @param sendtype  datatype of each item in send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of items to receive
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iNeighborAllToAll(
-			Buffer sendbuf, int sendcount, Datatype sendtype,
-			Buffer recvbuf, int recvcount, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iNeighborAllToAll(
-				handle, sendbuf, sendcount, sendtype.handle,
-				recvbuf, recvcount, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	private native long iNeighborAllToAll(
-			long comm, Buffer sendBuf, int sendCount, long sendType,
-			Buffer recvBuf, int recvCount, long recvType);
-
-	/**
-	 * Java binding of {@code MPI_NEIGHBOR_ALLTOALLV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each buffer
-	 * @param sdispls   displacements from which to take outgoing data
-	 * @param sendtype  datatype send buffer items
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param rdispls   displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void neighborAllToAllv(
-			Object sendbuf, int[] sendcount, int[] sdispls, Datatype sendtype,
-			Object recvbuf, int[] recvcount, int[] rdispls, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = sendtype.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = recvtype.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		neighborAllToAllv(handle,
-				sendbuf, sdb, sendoff, sendcount, sdispls,
-				sendtype.handle, sendtype.baseType,
-				recvbuf, rdb, recvoff, recvcount, rdispls,
-				recvtype.handle, recvtype.baseType);
-	}
-
-	private native void neighborAllToAllv(
-			long comm, Object sendBuf, boolean sdb, int sendOff,
-			int[] sendCount, int[] sdispls, long sendType, int sendBaseType,
-			Object recvBuf, boolean rdb, int recvOff,
-			int[] recvCount, int[] rdispls, long recvType, int recvBaseType)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_INEIGHBOR_ALLTOALLV}.
-	 * @param sendbuf   send buffer
-	 * @param sendcount number of items sent to each buffer
-	 * @param sdispls   displacements from which to take outgoing data
-	 * @param sendtype  datatype send buffer items
-	 * @param recvbuf   receive buffer
-	 * @param recvcount number of elements received from each process
-	 * @param rdispls   displacements at which to place incoming data
-	 * @param recvtype  datatype of each item in receive buffer
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iNeighborAllToAllv(
-			Buffer sendbuf, int[] sendcount, int[] sdispls, Datatype sendtype,
-			Buffer recvbuf, int[] recvcount, int[] rdispls, Datatype recvtype)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iNeighborAllToAllv(
-				handle, sendbuf, sendcount, sdispls, sendtype.handle,
-				recvbuf, recvcount, rdispls, recvtype.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	private native long iNeighborAllToAllv(
-			long comm, Buffer sendBuf, int[] sendCount, int[] sdispls, long sType,
-			Buffer recvBuf, int[] recvCount, int[] rdispls, long rType)
-					throws MPIException;
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and return the combined value in the output buffer of the
-	 * root process.
-	 * <p>
-	 * Java binding of the MPI operation {@code MPI_REDUCE}.
-	 * <p>
-	 * The predefined operations are available in Java as {@code MPI.MAX},
-	 * {@code MPI.MIN}, {@code MPI.SUM}, {@code MPI.PROD}, {@code MPI.LAND},
-	 * {@code MPI.BAND}, {@code MPI.LOR}, {@code MPI.BOR}, {@code MPI.LXOR},
-	 * {@code MPI.BXOR}, {@code MPI.MINLOC} and {@code MPI.MAXLOC}.
-	 * @param sendbuf send buffer
-	 * @param recvbuf receive buffer
-	 * @param count   number of items in send buffer
-	 * @param type    data type of each item in send buffer
-	 * @param op      reduce operation
-	 * @param root    rank of root process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void reduce(Object sendbuf, Object recvbuf, int count,
-			Datatype type, Op op, int root)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = type.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = type.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		reduce(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
-				count, type.handle, type.baseType, op, op.handle, root);
-	}
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and return the combined value in the output buffer of the
-	 * root process.
-	 * <p>Java binding of the MPI operation {@code MPI_REDUCE}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   send/receive buffer
-	 * @param count number of items in buffer
-	 * @param type  data type of each item in buffer
-	 * @param op    reduce operation
-	 * @param root  rank of root process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void reduce(Object buf, int count, Datatype type, Op op, int root)
-			throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		reduce(handle, null, false, 0, buf, db, off, count,
-				type.handle, type.baseType, op, op.handle, root);
-	}
-
-	private native void reduce(
-			long comm, Object sendbuf, boolean sdb, int sendoff,
-			Object recvbuf, boolean rdb, int recvoff, int count,
-			long type, int baseType, Op jOp, long hOp, int root)
-					throws MPIException;
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and return the combined value in the output buffer of the
-	 * root process.
-	 * <p>Java binding of the MPI operation {@code MPI_IREDUCE}.
-	 * @param sendbuf send buffer
-	 * @param recvbuf receive buffer
-	 * @param count   number of items in send buffer
-	 * @param type    data type of each item in send buffer
-	 * @param op      reduce operation
-	 * @param root    rank of root process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iReduce(Buffer sendbuf, Buffer recvbuf,
-			int count, Datatype type, Op op, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		op.setDatatype(type);
-		Request req = new Request(iReduce(
-				handle, sendbuf, recvbuf, count,
-				type.handle, type.baseType, op, op.handle, root));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and return the combined value in the output buffer of the
-	 * root process.
-	 * <p>Java binding of the MPI operation {@code MPI_IREDUCE}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   send/receive buffer
-	 * @param count number of items in buffer
-	 * @param type  data type of each item in buffer
-	 * @param op    reduce operation
-	 * @param root  rank of root process
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iReduce(Buffer buf, int count,
-			Datatype type, Op op, int root)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		op.setDatatype(type);
-		Request req = new Request(iReduce(
-				handle, null, buf, count,
-				type.handle, type.baseType, op, op.handle, root));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iReduce(
-			long comm, Buffer sendbuf, Buffer recvbuf, int count,
-			long type, int baseType, Op jOp, long hOp, int root)
-					throws MPIException;
-
-	/**
-	 * Same as {@code reduce} except that the result appears in receive
-	 * buffer of all process in the group.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLREDUCE}.
-	 * @param sendbuf send buffer
-	 * @param recvbuf receive buffer
-	 * @param count   number of items in send buffer
-	 * @param type    data type of each item in send buffer
-	 * @param op      reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allReduce(Object sendbuf, Object recvbuf,
-			int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = type.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = type.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		allReduce(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
-				count, type.handle, type.baseType, op, op.handle);
-	}
-
-	/**
-	 * Same as {@code reduce} except that the result appears in receive
-	 * buffer of all process in the group.
-	 * <p>Java binding of the MPI operation {@code MPI_ALLREDUCE}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer
-	 * @param count number of items in send buffer
-	 * @param type  data type of each item in send buffer
-	 * @param op    reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void allReduce(Object buf, int count, Datatype type, Op op)
-			throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		allReduce(handle, null, false, 0, buf, db, off, count,
-				type.handle, type.baseType, op, op.handle);
-	}
-
-	private native void allReduce(
-			long comm, Object sendbuf, boolean sdb, int sendoff,
-			Object recvbuf, boolean rdb, int recvoff, int count,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Same as {@code reduce} except that the result appears in receive
-	 * buffer of all process in the group.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLREDUCE}.
-	 * @param sendbuf send buffer
-	 * @param recvbuf receive buffer
-	 * @param count   number of items in send buffer
-	 * @param type    data type of each item in send buffer
-	 * @param op      reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllReduce(Buffer sendbuf, Buffer recvbuf,
-			int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(sendbuf, recvbuf);
-		op.setDatatype(type);
-		Request req = new Request(iAllReduce(handle, sendbuf, recvbuf, count,
-				type.handle, type.baseType, op, op.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Same as {@code reduce} except that the result appears in receive
-	 * buffer of all process in the group.
-	 * <p>Java binding of the MPI operation {@code MPI_IALLREDUCE}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer
-	 * @param count number of items in send buffer
-	 * @param type  data type of each item in send buffer
-	 * @param op    reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iAllReduce(Buffer buf, int count, Datatype type, Op op)
-			throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(buf);
-		Request req = new Request(iAllReduce(
-				handle, null, buf, count,
-				type.handle, type.baseType, op, op.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iAllReduce(
-			long comm, Buffer sendbuf, Buffer recvbuf, int count,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and scatter the combined values over the output buffers
-	 * of the processes.
-	 * <p>Java binding of the MPI operation {@code MPI_REDUCE_SCATTER}.
-	 * @param sendbuf    send buffer
-	 * @param recvbuf    receive buffer
-	 * @param recvcounts numbers of result elements distributed to each process
-	 * @param type       data type of each item in send buffer
-	 * @param op         reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void reduceScatter(Object sendbuf, Object recvbuf,
-			int[] recvcounts, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = type.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = type.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		reduceScatter(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
-				recvcounts, type.handle, type.baseType, op, op.handle);
-	}
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and scatter the combined values over the output buffers
-	 * of the processes.
-	 * <p>Java binding of the MPI operation {@code MPI_REDUCE_SCATTER}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf    receive buffer
-	 * @param counts numbers of result elements distributed to each process
-	 * @param type   data type of each item in send buffer
-	 * @param op     reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void reduceScatter(Object buf, int[] counts, Datatype type, Op op)
-			throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		reduceScatter(handle, null, false, 0, buf, db, off, counts,
-				type.handle, type.baseType, op, op.handle);
-	}
-
-	private native void reduceScatter(
-			long comm, Object sendbuf, boolean sdb, int sendoff,
-			Object recvbuf, boolean rdb, int recvoff, int[] recvcounts,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and scatter the combined values over the output buffers
-	 * of the processes.
-	 * <p>Java binding of the MPI operation {@code MPI_IREDUCE_SCATTER}.
-	 * @param sendbuf    send buffer
-	 * @param recvbuf    receive buffer
-	 * @param recvcounts numbers of result elements distributed to each process
-	 * @param type       data type of each item in send buffer
-	 * @param op         reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iReduceScatter(Buffer sendbuf, Buffer recvbuf,
-			int[] recvcounts, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iReduceScatter(
-				handle, sendbuf, recvbuf, recvcounts,
-				type.handle, type.baseType, op, op.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Combine elements in input buffer of each process using the reduce
-	 * operation, and scatter the combined values over the output buffers
-	 * of the processes.
-	 * <p>Java binding of the MPI operation {@code MPI_IREDUCE_SCATTER}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf    receive buffer
-	 * @param counts numbers of result elements distributed to each process
-	 * @param type   data type of each item in send buffer
-	 * @param op     reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iReduceScatter(
-			Buffer buf, int[] counts, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(buf);
-		Request req = new Request(iReduceScatter(
-				handle, null, buf, counts,
-				type.handle, type.baseType, op, op.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iReduceScatter(
-			long handle, Buffer sendbuf, Object recvbuf, int[] recvcounts,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Combine values and scatter the results.
-	 * <p>Java binding of the MPI operation {@code MPI_REDUCE_SCATTER_BLOCK}.
-	 * @param sendbuf   send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount element count per block
-	 * @param type      data type of each item in send buffer
-	 * @param op        reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void reduceScatterBlock(Object sendbuf, Object recvbuf,
-			int recvcount, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = type.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = type.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		reduceScatterBlock(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
-				recvcount, type.handle, type.baseType, op, op.handle);
-	}
-
-	/**
-	 * Combine values and scatter the results.
-	 * <p>Java binding of the MPI operation {@code MPI_REDUCE_SCATTER_BLOCK}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer
-	 * @param count element count per block
-	 * @param type  data type of each item in send buffer
-	 * @param op    reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void reduceScatterBlock(
-			Object buf, int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		reduceScatterBlock(handle, null, false, 0, buf, db, off, count,
-				type.handle, type.baseType, op, op.handle);
-	}
-
-	private native void reduceScatterBlock(
-			long comm, Object sendBuf, boolean sdb, int sOffset,
-			Object recvBuf, boolean rdb, int rOffset, int rCount,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Combine values and scatter the results.
-	 * <p>Java binding of the MPI operation {@code MPI_IREDUCE_SCATTER_BLOCK}.
-	 * @param sendbuf   send buffer
-	 * @param recvbuf   receive buffer
-	 * @param recvcount element count per block
-	 * @param type      data type of each item in send buffer
-	 * @param op        reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iReduceScatterBlock(
-			Buffer sendbuf, Buffer recvbuf, int recvcount, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iReduceScatterBlock(
-				handle, sendbuf, recvbuf, recvcount,
-				type.handle, type.baseType, op, op.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Combine values and scatter the results.
-	 * <p>Java binding of the MPI operation {@code MPI_IREDUCE_SCATTER_BLOCK}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer
-	 * @param count element count per block
-	 * @param type  data type of each item in send buffer
-	 * @param op    reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iReduceScatterBlock(
-			Buffer buf, int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(buf);
-		Request req = new Request(iReduceScatterBlock(
-				handle, null, buf, count, type.handle,
-				type.baseType, op, op.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iReduceScatterBlock(
-			long handle, Buffer sendbuf, Buffer recvbuf, int recvcount,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Apply the operation given by {@code op} element-wise to the
-	 * elements of {@code inBuf} and {@code inOutBuf} with the result
-	 * stored element-wise in {@code inOutBuf}.
-	 * <p>Java binding of the MPI operation {@code MPI_REDUCE_LOCAL}.
-	 * @param inBuf    input buffer
-	 * @param inOutBuf input buffer, will contain combined output
-	 * @param count    number of elements
-	 * @param type     data type of each item
-	 * @param op       reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void reduceLocal(
-			Object inBuf, Object inOutBuf, int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-
-		int inOff    = 0,
-				inOutOff = 0;
-
-		boolean idb  = false,
-				iodb = false;
-
-		if(inBuf instanceof Buffer && !(idb = ((Buffer)inBuf).isDirect()))
-		{
-			inOff = type.getOffset(inBuf);
-			inBuf = ((Buffer)inBuf).array();
-		}
-
-		if(inOutBuf instanceof Buffer && !(iodb = ((Buffer)inOutBuf).isDirect()))
-		{
-			inOutOff = type.getOffset(inOutBuf);
-			inOutBuf = ((Buffer)inOutBuf).array();
-		}
-
-		if(op.uf == null)
-		{
-			reduceLocal(inBuf, idb, inOff, inOutBuf, iodb, inOutOff,
-					count, type.handle, op.handle);
-		}
-		else
-		{
-			reduceLocalUf(inBuf, idb, inOff, inOutBuf, iodb, inOutOff,
-					count, type.handle, type.baseType, op, op.handle);
-		}
-	}
-
-	private static native void reduceLocal(
-			Object inBuf, boolean idb, int inOff,
-			Object inOutBuf, boolean iodb, int inOutOff, int count,
-			long type, long op) throws MPIException;
-
-	private static native void reduceLocalUf(
-			Object inBuf, boolean idb, int inOff,
-			Object inOutBuf, boolean iodb, int inOutOff, int count,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Sets the print name for the communicator.
-	 * @param name name for the communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void setName(String name) throws MPIException
-	{
-		MPI.check();
-		setName(handle, name);
-	}
-
-	private native void setName(long handle, String name) throws MPIException;
-
-	/**
-	 * Return the print name from the communicator.
-	 * @return name of the communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final String getName() throws MPIException
-	{
-		MPI.check();
-		return getName(handle);
-	}
-
-	private native String getName(long handle) throws MPIException;
-
-	/**
-	 * A helper method to convert an array of Datatypes to
-	 * an array of longs (handles).
-	 * @param dArray	Array of Datatypes
-	 * @return converted Datatypes
-	 */
-	private long[] convertTypeArray(Datatype[] dArray) {
-		long[] lArray = new long[dArray.length];
-
-		for(int i = 0; i < lArray.length; i++) {
-			if(dArray[i] != null) {
-				lArray[i] = dArray[i].handle;
-			}
-		}
-		return lArray;
-	}
-
-	/**
-	 * A helper method to convert an array of Datatypes to
-	 * an array of ints (basetypes).
-	 * @param dArray	Array of Datatypes
-	 * @return converted basetypes
-	 */
-	private int[] convertTypeArrayBtype(Datatype[] dArray) {
-		int[] lArray = new int[dArray.length];
-
-		for(int i = 0; i < lArray.length; i++) {
-			if(dArray[i] != null) {
-				lArray[i] = dArray[i].baseType;
-			}
-		}
-		return lArray;
-	}
-
-} // Comm
diff --git a/ompi/mpi/java/java/Constant.java b/ompi/mpi/java/java/Constant.java
deleted file mode 100644
index a5e95708b70..00000000000
--- a/ompi/mpi/java/java/Constant.java
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2020 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-class Constant
-{
-	protected int THREAD_SINGLE, THREAD_FUNNELED, THREAD_SERIALIZED, THREAD_MULTIPLE;
-
-	protected int GRAPH, DIST_GRAPH, CART;
-	protected int ANY_SOURCE, ANY_TAG;
-	protected int PROC_NULL;
-	protected int UNDEFINED;
-	protected int IDENT, CONGRUENT, SIMILAR, UNEQUAL;
-	protected int TAG_UB, HOST, IO, WTIME_IS_GLOBAL;
-
-	protected int APPNUM, LASTUSEDCODE, UNIVERSE_SIZE, WIN_BASE, WIN_SIZE, WIN_DISP_UNIT;
-
-	protected int VERSION, SUBVERSION;
-	protected int ROOT, KEYVAL_INVALID, BSEND_OVERHEAD;
-	protected int MAX_OBJECT_NAME, MAX_PORT_NAME, MAX_DATAREP_STRING;
-	protected int MAX_INFO_KEY, MAX_INFO_VAL;
-	protected int ORDER_C, ORDER_FORTRAN;
-
-	protected int DISTRIBUTE_BLOCK, DISTRIBUTE_CYCLIC, DISTRIBUTE_NONE, DISTRIBUTE_DFLT_DARG;
-
-	protected int MODE_CREATE, MODE_RDONLY, MODE_WRONLY, MODE_RDWR,
-		MODE_DELETE_ON_CLOSE, MODE_UNIQUE_OPEN, MODE_EXCL,
-		MODE_APPEND, MODE_SEQUENTIAL;
-
-	protected int DISPLACEMENT_CURRENT;
-	protected int SEEK_SET, SEEK_CUR, SEEK_END;
-
-	protected int MODE_NOCHECK, MODE_NOPRECEDE, MODE_NOPUT, MODE_NOSTORE,
-		MODE_NOSUCCEED;
-
-	protected int LOCK_EXCLUSIVE, LOCK_SHARED;
-
-	// Error classes and codes
-	protected int SUCCESS;
-	protected int ERR_BUFFER;
-	protected int ERR_COUNT;
-	protected int ERR_TYPE;
-	protected int ERR_TAG;
-	protected int ERR_COMM;
-	protected int ERR_RANK;
-	protected int ERR_REQUEST;
-	protected int ERR_ROOT;
-	protected int ERR_GROUP;
-	protected int ERR_OP;
-	protected int ERR_TOPOLOGY;
-	protected int ERR_DIMS;
-	protected int ERR_ARG;
-	protected int ERR_UNKNOWN;
-	protected int ERR_TRUNCATE;
-	protected int ERR_OTHER;
-	protected int ERR_INTERN;
-	protected int ERR_IN_STATUS;
-	protected int ERR_PENDING;
-	protected int ERR_ACCESS;
-	protected int ERR_AMODE;
-	protected int ERR_ASSERT;
-	protected int ERR_BAD_FILE;
-	protected int ERR_BASE;
-	protected int ERR_CONVERSION;
-	protected int ERR_DISP;
-	protected int ERR_DUP_DATAREP;
-	protected int ERR_FILE_EXISTS;
-	protected int ERR_FILE_IN_USE;
-	protected int ERR_FILE;
-	protected int ERR_INFO_KEY;
-	protected int ERR_INFO_NOKEY;
-	protected int ERR_INFO_VALUE;
-	protected int ERR_INFO;
-	protected int ERR_IO;
-	protected int ERR_KEYVAL;
-	protected int ERR_LOCKTYPE;
-	protected int ERR_NAME;
-	protected int ERR_NO_MEM;
-	protected int ERR_NOT_SAME;
-	protected int ERR_NO_SPACE;
-	protected int ERR_NO_SUCH_FILE;
-	protected int ERR_PORT;
-	protected int ERR_PROC_ABORTED;
-	protected int ERR_QUOTA;
-	protected int ERR_READ_ONLY;
-	protected int ERR_RMA_CONFLICT;
-	protected int ERR_RMA_SYNC;
-	protected int ERR_SERVICE;
-	protected int ERR_SIZE;
-	protected int ERR_SPAWN;
-	protected int ERR_UNSUPPORTED_DATAREP;
-	protected int ERR_UNSUPPORTED_OPERATION;
-	protected int ERR_WIN;
-	protected int ERR_LASTCODE;
-	protected int ERR_SYSRESOURCE;
-
-	protected Constant()
-	{
-		setConstant();
-	}
-
-	private native void setConstant();
-
-} // Constant
diff --git a/ompi/mpi/java/java/Count.java b/ompi/mpi/java/java/Count.java
deleted file mode 100644
index 7c175c4549f..00000000000
--- a/ompi/mpi/java/java/Count.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Count.java
- * Author       : Nathaniel Graham
- * Created      : Thu Jul  29 17:13 2015
- */
-
-package mpi;
-
-/**
- * This class represents {@code MPI_Count}.
- */
-public final class Count implements Comparable
-{
-	private long count;
-
-	static
-	{
-		System.loadLibrary("mpi_java");
-		initCount();
-	}
-
-	private static native void initCount();
-
-	public Count(long count)
-	{
-		this.count = count;
-	}
-
-	/**
-	 * Gets value associated with this Count object.
-	 * @return Count value
-	 */
-	public long getCount()
-	{
-		return this.count;
-	}
-
-	/**
-	 * Sets the value associated with this Count object.
-	 * @param count	the value to set for this count object
-	 */
-	public void setCount(long count)
-	{
-		this.count = count;
-	}
-
-	@Override
-	public boolean equals(Object obj)
-	{
-		if(obj instanceof Count) {
-			if(this.count == ((Count)obj).getCount()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	public int compareTo(Object obj)
-	{
-		if(obj instanceof Count) {
-			if(this.count - ((Count)obj).getCount() > 0) {
-				return 1;
-			} else if(this.count - ((Count)obj).getCount() == 0) {
-				return 0;
-			}
-		}
-		return -1;
-	}
-} // Count
diff --git a/ompi/mpi/java/java/Datatype.java b/ompi/mpi/java/java/Datatype.java
deleted file mode 100644
index 4b9e8295f43..00000000000
--- a/ompi/mpi/java/java/Datatype.java
+++ /dev/null
@@ -1,581 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Datatype.java
- * Author       : Sang Lim, Sung-Hoon Ko, Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.14 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-import java.nio.*;
-
-/**
- * The {@code Datatype} class represents {@code MPI_Datatype} handles.
- */
-public final class Datatype implements Freeable, Cloneable
-{
-	protected long handle;
-	protected int baseType;
-	protected int baseSize;
-
-	// Cache to avoid unnecessary jni calls.
-	private int lb, extent, trueLb, trueExtent;
-
-	protected static final int NULL       =  0;
-	protected static final int BYTE       =  1;
-	protected static final int CHAR       =  2;
-	protected static final int SHORT      =  3;
-	protected static final int BOOLEAN    =  4;
-	protected static final int INT        =  5;
-	protected static final int LONG       =  6;
-	protected static final int FLOAT      =  7;
-	protected static final int DOUBLE     =  8;
-	protected static final int PACKED     =  9;
-	protected static final int INT2       = 10;
-	protected static final int SHORT_INT  = 11;
-	protected static final int LONG_INT   = 12;
-	protected static final int FLOAT_INT  = 13;
-	protected static final int DOUBLE_INT = 14;
-	protected static final int FLOAT_COMPLEX  = 15;
-	protected static final int DOUBLE_COMPLEX = 16;
-
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	/*
-	 * Constructor used in static initializer of 'MPI'.
-	 *
-	 * (Called before MPI.Init(), so cannot make any native MPI calls.)
-	 *
-	 * (Initialization done in separate 'setBasic', so can create
-	 * datatype objects for 'BYTE', etc in static initializers invoked before
-	 * MPI.Init(), then initialize objects after MPI initialized.)
-	 */
-	protected Datatype()
-	{
-	}
-
-	protected void setBasic(int type)
-	{
-		baseType = type;
-		handle   = getDatatype(type);
-		baseSize = type == NULL ? 0 : getSize(handle);
-	}
-
-	protected void setBasic(int type, Datatype oldType)
-	{
-		baseType = oldType.baseType;
-		handle   = getDatatype(type);
-		baseSize = oldType.baseSize;
-	}
-
-	private static native long getDatatype(int type);
-
-	/*
-	 * Constructor used in 'create*' methods.
-	 */
-	private Datatype(Datatype oldType, long handle)
-	{
-		baseType = oldType.baseType;
-		baseSize = oldType.baseSize;
-		this.handle = handle;
-	}
-
-	/*
-	 * Constructor used in 'create*' methods.
-	 */
-	private Datatype(int baseType, int baseSize, long handle)
-	{
-		this.baseType = baseType;
-		this.baseSize = baseSize;
-		this.handle   = handle;
-	}
-
-	/**
-	 * Returns the lower bound of a datatype.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_GET_EXTENT}.
-	 * @return lower bound of datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getLb() throws MPIException
-	{
-		if(extent == 0)
-			getLbExtent();
-
-		return lb;
-	}
-
-	/**
-	 * Returns the extent of a datatype.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_GET_EXTENT}.
-	 * @return datatype extent
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getExtent() throws MPIException
-	{
-		if(extent == 0)
-			getLbExtent();
-
-		return extent;
-	}
-
-	private void getLbExtent() throws MPIException
-	{
-		MPI.check();
-		int lbExt[] = new int[2];
-		getLbExtent(handle, lbExt);
-		lb     = lbExt[0] / baseSize;
-		extent = lbExt[1] / baseSize;
-	}
-
-	private native void getLbExtent(long handle, int[] lbExt);
-
-	/**
-	 * Returns the true lower bound of a datatype.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_GET_TRUE_EXTENT}.
-	 * @return lower bound of datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getTrueLb() throws MPIException
-	{
-		if(trueExtent == 0)
-			getTrueLbExtent();
-
-		return trueLb;
-	}
-
-	/**
-	 * Returns the true extent of a datatype.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_GET_TRUE_EXTENT}.
-	 * @return datatype true extent
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getTrueExtent() throws MPIException
-	{
-		if(trueExtent == 0)
-			getTrueLbExtent();
-
-		return trueExtent;
-	}
-
-	private void getTrueLbExtent() throws MPIException
-	{
-		MPI.check();
-		int lbExt[] = new int[2];
-		getTrueLbExtent(handle, lbExt);
-		trueLb     = lbExt[0] / baseSize;
-		trueExtent = lbExt[1] / baseSize;
-	}
-
-	private native void getTrueLbExtent(long handle, int[] lbExt);
-
-	/**
-	 * Returns the total size of a datatype - the number of buffer
-	 * elements it represents.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_SIZE}.
-	 * @return datatype size
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getSize() throws MPIException
-	{
-		MPI.check();
-		return getSize(handle) / baseSize;
-	}
-
-	private native int getSize(long type);
-
-	/**
-	 * Commits a derived datatype.
-	 * Java binding of the MPI operation {@code MPI_TYPE_COMMIT}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void commit() throws MPIException
-	{
-		MPI.check();
-		commit(handle);
-	}
-
-	private native void commit(long type);
-
-	/**
-	 * Frees the datatype.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_FREE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public void free() throws MPIException
-	{
-		MPI.check();
-		handle = free(handle);
-	}
-
-	private native long free(long type) throws MPIException;
-
-	/**
-	 * Returns {@code true} if this datatype is MPI_DATATYPE_NULL.
-	 * @return {@code true} if this datatype is MPI_DATATYPE_NULL
-	 */
-	public boolean isNull()
-	{
-		return handle == MPI.DATATYPE_NULL.handle;
-	}
-
-	/**
-	 * Java binding of {@code MPI_TYPE_DUP}.
-	 * <p>It is recommended to use {@link #dup} instead of {@link #clone}
-	 * because the last can't throw an {@link mpi.MPIException}.
-	 * @return new datatype
-	 */
-	@Override public Datatype clone()
-	{
-		try
-		{
-			return dup();
-		}
-		catch(MPIException e)
-		{
-			throw new RuntimeException(e.getMessage());
-		}
-	}
-
-	/**
-	 * Java binding of {@code MPI_TYPE_DUP}.
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Datatype dup() throws MPIException
-	{
-		MPI.check();
-		return new Datatype(this, dup(handle));
-	}
-
-	private native long dup(long type) throws MPIException;
-
-	/**
-	 * Construct new datatype representing replication of old datatype into
-	 * contiguous locations.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_CONTIGUOUS}.
-	 * <p>The base type of the new datatype is the same as the base type of
-	 * {@code oldType}.
-	 * @param count   replication count
-	 * @param oldType old datatype
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Datatype createContiguous(int count, Datatype oldType)
-			throws MPIException
-	{
-		MPI.check();
-		return new Datatype(oldType, getContiguous(count, oldType.handle));
-	}
-
-	private static native long getContiguous(int count, long oldType);
-
-	/**
-	 * Construct new datatype representing replication of old datatype into
-	 * locations that consist of equally spaced blocks.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_VECTOR}.
-	 * <p>The base type of the new datatype is the same as the base type of
-	 * {@code oldType}.
-	 * @param count       number of blocks
-	 * @param blockLength number of elements in each block
-	 * @param stride      number of elements between start of each block
-	 * @param oldType     old datatype
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Datatype createVector(int count, int blockLength,
-			int stride, Datatype oldType)
-					throws MPIException
-	{
-		MPI.check();
-		long handle = getVector(count, blockLength, stride, oldType.handle);
-		return new Datatype(oldType, handle);
-	}
-
-	private static native long getVector(
-			int count, int blockLength, int stride, long oldType)
-					throws MPIException;
-
-	/**
-	 * Identical to {@code createVector} except that the stride is expressed
-	 * directly in terms of the buffer index, rather than the units of
-	 * the old type.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_CREATE_HVECTOR}.
-	 * @param count       number of blocks
-	 * @param blockLength number of elements in each
-	 * @param stride      number of bytes between start of each block
-	 * @param oldType     old datatype
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Datatype createHVector(int count, int blockLength,
-			int stride, Datatype oldType)
-					throws MPIException
-	{
-		MPI.check();
-		long handle = getHVector(count, blockLength, stride, oldType.handle);
-		return new Datatype(oldType, handle);
-	}
-
-	private static native long getHVector(
-			int count, int blockLength, int stride, long oldType)
-					throws MPIException;
-
-	/**
-	 * Construct new datatype representing replication of old datatype into
-	 * a sequence of blocks where each block can contain a different number
-	 * of copies and have a different displacement.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_INDEXED}.
-	 * <p>The number of blocks is taken to be size of the {@code blockLengths}
-	 * argument. The second argument, {@code displacements}, should be the
-	 * same size. The base type of the new datatype is the same as the base
-	 * type of {@code oldType}.
-	 * @param blockLengths  number of elements per block
-	 * @param displacements displacement of each block in units of old type
-	 * @param oldType       old datatype
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Datatype createIndexed(int[] blockLengths,
-			int[] displacements, Datatype oldType)
-					throws MPIException
-	{
-		MPI.check();
-		long handle = getIndexed(blockLengths, displacements, oldType.handle);
-		return new Datatype(oldType, handle);
-	}
-
-	private static native long getIndexed(
-			int[] blockLengths, int[] displacements, long oldType)
-					throws MPIException;
-
-	/**
-	 * Identical to {@code createIndexed} except that the displacements are
-	 * expressed directly in terms of the buffer index, rather than the
-	 * units of the old type.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_CREATE_HINDEXED}.
-	 * @param blockLengths  number of elements per block
-	 * @param displacements byte displacement in buffer for each block
-	 * @param oldType       old datatype
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Datatype createHIndexed(int[] blockLengths,
-			int[] displacements, Datatype oldType)
-					throws MPIException
-	{
-		MPI.check();
-		long handle = getHIndexed(blockLengths, displacements, oldType.handle);
-		return new Datatype(oldType, handle);
-	}
-
-	private static native long getHIndexed(
-			int[] blockLengths, int[] displacements, long oldType)
-					throws MPIException;
-
-	/**
-	 * The most general type constructor.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_CREATE_STRUCT}.
-	 * <p>The number of blocks is taken to be size of the {@code blockLengths}
-	 * argument. The second and third arguments, {@code displacements},
-	 * and {@code types}, should be the same size.
-	 * @param blockLengths  number of elements in each block
-	 * @param displacements byte displacement of each block
-	 * @param types         type of elements in each block
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Datatype createStruct(int[] blockLengths,
-			int[] displacements, Datatype[] types)
-					throws MPIException
-	{
-		MPI.check();
-		long handle = getStruct(blockLengths, displacements, types);
-		return new Datatype(MPI.BYTE, handle);
-	}
-
-	private static native long getStruct(
-			int[] blockLengths, int[] displacements, Datatype[] types)
-					throws MPIException;
-
-	/*
-	 * JMS add proper documentation here
-	 * JMS int != Aint!  This needs to be fixed throughout.
-	 */
-	/**
-	 * Create a datatype with a new lower bound and extent from an existing
-	 * datatype.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_CREATE_RESIZED}.
-	 * @param oldType input datatype
-	 * @param lb      new lower bound of datatype (address integer)
-	 * @param extent  new extent of datatype (address integer)
-	 * @return new datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Datatype createResized(Datatype oldType, int lb, int extent)
-			throws MPIException
-	{
-		MPI.check();
-		long handle = getResized(oldType.handle, lb, extent);
-		return new Datatype(oldType, handle);
-	}
-
-	private static native long getResized(long oldType, int lb, int extent);
-
-	/**
-	 * Sets the print name for the datatype.
-	 * @param name name for the datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setName(String name) throws MPIException
-	{
-		MPI.check();
-		setName(handle, name);
-	}
-
-	private native void setName(long handle, String name) throws MPIException;
-
-	/**
-	 * Return the print name from the datatype.
-	 * @return name of the datatype
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public String getName() throws MPIException
-	{
-		MPI.check();
-		return getName(handle);
-	}
-
-	private native String getName(long handle) throws MPIException;
-
-	/**
-	 * Create a new attribute key.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_CREATE_KEYVAL}.
-	 * @return attribute key for future access
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int createKeyval() throws MPIException
-	{
-		MPI.check();
-		return createKeyval_jni();
-	}
-
-	private static native int createKeyval_jni() throws MPIException;
-
-	/**
-	 * Frees an attribute key.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_FREE_KEYVAL}.
-	 * @param keyval attribute key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void freeKeyval(int keyval) throws MPIException
-	{
-		MPI.check();
-		freeKeyval_jni(keyval);
-	}
-
-	private static native void freeKeyval_jni(int keyval) throws MPIException;
-
-	/**
-	 * Stores attribute value associated with a key.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_SET_ATTR}.
-	 * @param keyval attribute key
-	 * @param value  attribute value
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setAttr(int keyval, Object value) throws MPIException
-	{
-		MPI.check();
-		setAttr(handle, keyval, MPI.attrSet(value));
-	}
-
-	private native void setAttr(long type, int keyval, byte[] value)
-			throws MPIException;
-
-	/**
-	 * Retrieves attribute value by key.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_GET_ATTR}.
-	 * @param keyval attribute key
-	 * @return attribute value or null if no attribute is associated with the key.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Object getAttr(int keyval) throws MPIException
-	{
-		MPI.check();
-		Object obj = getAttr(handle, keyval);
-		return obj instanceof byte[] ? MPI.attrGet((byte[])obj) : obj;
-	}
-
-	private native Object getAttr(long type, int keyval) throws MPIException;
-
-	/**
-	 * Deletes an attribute value associated with a key.
-	 * <p>Java binding of the MPI operation {@code MPI_TYPE_DELETE_ATTR}.
-	 * @param keyval attribute key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void deleteAttr(int keyval) throws MPIException
-	{
-		MPI.check();
-		deleteAttr(handle, keyval);
-	}
-
-	private native void deleteAttr(long type, int keyval) throws MPIException;
-
-	/**
-	 * Gets the offset of a buffer in bytes.
-	 * @param buffer buffer
-	 * @return offset in bytes
-	 */
-	protected int getOffset(Object buffer)
-	{
-		return baseSize * ((Buffer)buffer).arrayOffset();
-	}
-
-} // Datatype
diff --git a/ompi/mpi/java/java/DistGraphNeighbors.java b/ompi/mpi/java/java/DistGraphNeighbors.java
deleted file mode 100644
index e96243bb0d8..00000000000
--- a/ompi/mpi/java/java/DistGraphNeighbors.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * Adjacency information for a distributed graph topology.
- */
-public final class DistGraphNeighbors
-{
-	private final int[] sources, sourceWeights, destinations, destWeights;
-	private final boolean weighted;
-
-	protected DistGraphNeighbors(
-			int[] sources, int[] sourceWeights,
-			int[] destinations, int[] destWeights, boolean weighted)
-	{
-		this.sources       = sources;
-		this.sourceWeights = sourceWeights;
-		this.destinations  = destinations;
-		this.destWeights   = destWeights;
-		this.weighted      = weighted;
-	}
-
-	/**
-	 * Gets the number of edges into this process.
-	 * @return number of edges into this process
-	 */
-	public int getInDegree()
-	{
-		return sources.length;
-	}
-
-	/**
-	 * Gets the number of edges out of this process.
-	 * @return number of edges out of this process
-	 */
-	public int getOutDegree()
-	{
-		return destinations.length;
-	}
-
-	/**
-	 * Returns false if {@code MPI_UNWEIGHTED} was supplied during creation.
-	 * @return false if {@code MPI_UNWEIGHTED} was supplied, true otherwise
-	 */
-	public boolean isWeighted()
-	{
-		return weighted;
-	}
-
-	/**
-	 * Gets a process for which the calling process is a destination.
-	 * @param i source index
-	 * @return process for which the calling process is a destination
-	 */
-	public int getSource(int i)
-	{
-		return sources[i];
-	}
-
-	/**
-	 * Gets the weight of an edge into the calling process.
-	 * @param i source index
-	 * @return weight of the edge into the calling process
-	 */
-	public int getSourceWeight(int i)
-	{
-		return sourceWeights[i];
-	}
-
-	/**
-	 * Gets a process for which the calling process is a source
-	 * @param i destination index
-	 * @return process for which the calling process is a source
-	 */
-	public int getDestination(int i)
-	{
-		return destinations[i];
-	}
-
-	/**
-	 * Gets the weight of an edge out of the calling process.
-	 * @param i destination index
-	 * @return weight of an edge out of the calling process
-	 */
-	public int getDestinationWeight(int i)
-	{
-		return destWeights[i];
-	}
-
-} // DistGraphNeighbors
diff --git a/ompi/mpi/java/java/DoubleComplex.java b/ompi/mpi/java/java/DoubleComplex.java
deleted file mode 100644
index 3a75e3e6866..00000000000
--- a/ompi/mpi/java/java/DoubleComplex.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-import java.nio.*;
-
-/**
- * This class wraps a complex number stored in a buffer.
- */
-public final class DoubleComplex
-{
-	private final int offset;
-	private final DoubleBuffer buffer;
-
-	private DoubleComplex(DoubleBuffer buffer, int index)
-	{
-		this.buffer = buffer;
-		this.offset = index * 2;
-	}
-
-	/**
-	 * Wraps a complex number stored in a buffer
-	 * @param buffer buffer
-	 * @return complex number
-	 */
-	public static DoubleComplex get(DoubleBuffer buffer)
-	{
-		return new DoubleComplex(buffer, 0);
-	}
-
-	/**
-	 * Wraps the complex number at the specified position
-	 * of an array of complex numbers stored in a buffer.
-	 * @param buffer buffer
-	 * @param index  index
-	 * @return complex number
-	 */
-	public static DoubleComplex get(DoubleBuffer buffer, int index)
-	{
-		return new DoubleComplex(buffer, index);
-	}
-
-	/**
-	 * Wraps a complex number stored in the first two values of an array.
-	 * @param  array array
-	 * @return complex number
-	 */
-	public static DoubleComplex get(double[] array)
-	{
-		return new DoubleComplex(DoubleBuffer.wrap(array), 0);
-	}
-
-	/**
-	 * Wraps the complex number at the specified position of
-	 * an array of complex numbers stored in an array of doubles.
-	 * @param array array
-	 * @param index index
-	 * @return complex number
-	 */
-	public static DoubleComplex get(double[] array, int index)
-	{
-		return new DoubleComplex(DoubleBuffer.wrap(array), index);
-	}
-
-	/**
-	 * Wraps a complex number stored in a buffer
-	 * @param buffer buffer
-	 * @return complex number
-	 */
-	public static DoubleComplex get(ByteBuffer buffer)
-	{
-		return new DoubleComplex(buffer.asDoubleBuffer(), 0);
-	}
-
-	/**
-	 * Wraps the complex number at the specified position
-	 * of an array of complex numbers stored in a buffer.
-	 * @param buffer buffer
-	 * @param index  index
-	 * @return complex number
-	 */
-	public static DoubleComplex get(ByteBuffer buffer, int index)
-	{
-		return new DoubleComplex(buffer.asDoubleBuffer(), index);
-	}
-
-	/**
-	 * Gets the real value.
-	 * @return real value
-	 */
-	public double getReal()
-	{
-		return buffer.get(offset);
-	}
-
-	/**
-	 * Gets the imaginary value.
-	 * @return imaginary value.
-	 */
-	public double getImag()
-	{
-		return buffer.get(offset + 1);
-	}
-
-	/**
-	 * Puts the real value.
-	 * @param real real value
-	 */
-	public void putReal(double real)
-	{
-		buffer.put(offset, real);
-	}
-
-	/**
-	 * Puts the imaginary value.
-	 * @param imag imaginary value
-	 */
-	public void putImag(double imag)
-	{
-		buffer.put(offset + 1, imag);
-	}
-
-	/**
-	 * Gets the buffer where the complex number is stored.
-	 * @return buffer where the complex number is stored
-	 */
-	public DoubleBuffer getBuffer()
-	{
-		return offset == 0 ? buffer : MPI.slice(buffer, offset);
-	}
-
-} // DoubleComplex
diff --git a/ompi/mpi/java/java/DoubleInt.java b/ompi/mpi/java/java/DoubleInt.java
deleted file mode 100644
index ac75ffb5e7a..00000000000
--- a/ompi/mpi/java/java/DoubleInt.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * Struct class for {@link MPI#DOUBLE_INT} datatype.
- */
-public final class DoubleInt extends Struct
-{
-	private final int iOff, iSize;
-
-	/**
-	 * The struct object will be created only in MPI class.
-	 * @param intOff	int offset
-	 * @param intSize	int size
-	 * @see MPI#doubleInt
-	 */
-	protected DoubleInt(int intOff, int intSize)
-	{
-		int dOff = addDouble();
-		assert dOff == 0;
-
-		iSize = intSize;
-		setOffset(intOff);
-
-		switch(iSize)
-		{
-		case 4: iOff = addInt();  break;
-		case 8: iOff = addLong(); break;
-		default: throw new AssertionError("Unsupported int size: "+ iSize);
-		}
-
-		assert(intOff == iOff);
-	}
-
-	/**
-	 * Creates a Data object.
-	 * @return new Data object.
-	 */
-	@Override protected DoubleInt.Data newData()
-	{
-		return new DoubleInt.Data();
-	}
-
-	/**
-	 * Class for reading/writing data in a struct stored in a byte buffer.
-	 */
-	public final class Data extends Struct.Data
-	{
-		/**
-		 * Gets the double value.
-		 * @return double value
-		 */
-		public double getValue()
-		{
-			return getDouble(0);
-		}
-
-		/**
-		 * Gets the int value.
-		 * @return int value
-		 */
-		public int getIndex()
-		{
-			switch(iSize)
-			{
-			case 4: return getInt(iOff);
-			case 8: return (int)getLong(iOff);
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Puts the double value.
-		 * @param v double value
-		 */
-		public void putValue(double v)
-		{
-			putDouble(0, v);
-		}
-
-		/**
-		 * Puts the int value.
-		 * @param v int value
-		 */
-		public void putIndex(int v)
-		{
-			switch(iSize)
-			{
-			case 4: putInt(iOff, v);  break;
-			case 8: putLong(iOff, v); break;
-			default: throw new AssertionError();
-			}
-		}
-	} // Data
-
-} // DoubleInt
diff --git a/ompi/mpi/java/java/Errhandler.java b/ompi/mpi/java/java/Errhandler.java
deleted file mode 100644
index cc7fa6e73e1..00000000000
--- a/ompi/mpi/java/java/Errhandler.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2020 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Errhandler.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.3 $
- * Updated      : $Date: 2001/08/07 16:36:25 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * Error handler.
- */
-public final class Errhandler
-{
-	protected long handle;
-
-	protected static native long getFatal();
-	protected static native long getAbort();
-	protected static native long getReturn();
-
-	protected Errhandler(long handle)
-	{
-		this.handle = handle;
-	}
-
-} // Errhandler
diff --git a/ompi/mpi/java/java/File.java b/ompi/mpi/java/java/File.java
deleted file mode 100644
index 08534be2744..00000000000
--- a/ompi/mpi/java/java/File.java
+++ /dev/null
@@ -1,1389 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2017-2018 FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * IMPLEMENTATION DETAILS
- *
- * All methods with buffers that can be direct or non direct have
- * a companion argument 'db' which is true if the buffer is direct.
- *
- * Checking if a buffer is direct is faster in Java than C.
- */
-
-package mpi;
-
-import java.nio.*;
-import static mpi.MPI.isHeapBuffer;
-import static mpi.MPI.isDirectBuffer;
-import static mpi.MPI.assertDirectBuffer;
-
-/**
- * This class represents {@code MPI_File}.
- */
-public final class File
-{
-	private long handle;
-	private FileView view = new FileView(0, MPI.BYTE, MPI.BYTE, "native");
-	private Status beginStatus;
-
-	/**
-	 * Java binding of {@code MPI_FILE_OPEN} using {@code MPI_INFO_NULL}.
-	 * @param comm     communicator
-	 * @param filename name of the file to open
-	 * @param amode    file access mode
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public File(Comm comm, String filename, int amode) throws MPIException
-	{
-		MPI.check();
-		handle = open(comm.handle, filename, amode, Info.NULL);
-	}
-
-	/**
-	 * Java binding of {@code MPI_FILE_OPEN}.
-	 * @param comm     communicator
-	 * @param filename name of the file to open
-	 * @param amode    file access mode
-	 * @param info     info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public File(Comm comm, String filename, int amode, Info info)
-			throws MPIException
-	{
-		MPI.check();
-		handle = open(comm.handle, filename, amode, info.handle);
-	}
-
-	private native long open(long comm, String filename, int amode, long info)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_CLOSE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void close() throws MPIException
-	{
-		MPI.check();
-		handle = close(handle);
-	}
-
-	private native long close(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_DELETE} using {@code MPI_INFO_NULL}.
-	 * @param filename name of the file to delete
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void delete(String filename) throws MPIException
-	{
-		MPI.check();
-		delete(filename, Info.NULL);
-	}
-
-	/**
-	 * Java binding of {@code MPI_FILE_DELETE}.
-	 * @param filename name of the file to delete
-	 * @param info     info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void delete(String filename, Info info) throws MPIException
-	{
-		MPI.check();
-		delete(filename, info.handle);
-	}
-
-	private static native void delete(String filename, long info)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_SET_SIZE}.
-	 * @param size size to truncate or expand file
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setSize(long size) throws MPIException
-	{
-		MPI.check();
-		setSize(handle, size);
-	}
-
-	private native void setSize(long fh, long size) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_PREALLOCATE}.
-	 * @param size size to preallocate file
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void preallocate(long size) throws MPIException
-	{
-		MPI.check();
-		preallocate(handle, size);
-	}
-
-	private native void preallocate(long fh, long size) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_SIZE}.
-	 * @return size of file in bytes
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public long getSize() throws MPIException
-	{
-		MPI.check();
-		return getSize(handle);
-	}
-
-	private native long getSize(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_GROUP}.
-	 * @return group which opened the file
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Group getGroup() throws MPIException
-	{
-		MPI.check();
-		return new Group(getGroup(handle));
-	}
-
-	private native long getGroup(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_AMODE}.
-	 * @return file access mode to open the file
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getAMode() throws MPIException
-	{
-		MPI.check();
-		return getAMode(handle);
-	}
-
-	private native int getAMode(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_SET_INFO}.
-	 * @param info info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setInfo(Info info) throws MPIException
-	{
-		MPI.check();
-		setInfo(handle, info.handle);
-	}
-
-	private native void setInfo(long fh, long info) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_INFO}.
-	 * @return new info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Info getInfo() throws MPIException
-	{
-		MPI.check();
-		return new Info(getInfo(handle));
-	}
-
-	private native long getInfo(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_SET_VIEW} using {@code MPI_INFO_NULL}.
-	 * @param disp     displacement
-	 * @param etype    elementary datatype
-	 * @param filetype filetype
-	 * @param datarep  data representation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setView(long disp, Datatype etype,
-			Datatype filetype, String datarep)
-					throws MPIException
-	{
-		MPI.check();
-		setView(handle, disp, etype.handle, filetype.handle, datarep, Info.NULL);
-		view = new FileView(disp, etype, filetype, datarep);
-	}
-
-	/**
-	 * Java binding of {@code MPI_FILE_SET_VIEW}.
-	 * @param disp     displacement
-	 * @param etype    elementary datatype
-	 * @param filetype filetype
-	 * @param datarep  data representation
-	 * @param info     info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setView(long disp, Datatype etype,
-			Datatype filetype, String datarep, Info info)
-					throws MPIException
-	{
-		MPI.check();
-		setView(handle, disp, etype.handle, filetype.handle, datarep, info.handle);
-		view = new FileView(disp, etype, filetype, datarep);
-	}
-
-	private native void setView(
-			long fh, long disp, long etype,
-			long filetype, String datarep, long info) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_VIEW}.
-	 * @return file view
-	 */
-	public FileView getView()
-	{
-		return view;
-	}
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_AT}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readAt(long offset, Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		readAt(handle, offset, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void readAt(
-			long fh, long fileOffset, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_AT_ALL}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readAtAll(long offset, Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		readAtAll(handle, offset, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void readAtAll(
-			long fh, long fileOffset, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_AT}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeAt(long offset, Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		writeAt(handle, offset, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void writeAt(
-			long fh, long fileOffset, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_AT_ALL}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeAtAll(long offset, Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		writeAtAll(handle, offset, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void writeAtAll(
-			long fh, long fileOffset, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IREAD_AT}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iReadAt(long offset, Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iReadAt(handle, offset, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iReadAt(
-			long fh, long offset, Buffer buf, int count, long type)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IREAD_AT_ALL}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iReadAtAll(long offset, Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iReadAtAll(handle, offset, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iReadAtAll(
-			long fh, long offset, Buffer buf, int count, long type)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IWRITE_AT}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iWriteAt(long offset, Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iWriteAt(handle, offset, buf, count, type.handle));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iWriteAt(
-			long fh, long offset, Buffer buf, int count, long type)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IWRITE_AT_ALL}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iWriteAtAll(long offset, Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iWriteAtAll(handle, offset, buf, count, type.handle));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iWriteAtAll(
-			long fh, long offset, Buffer buf, int count, long type)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status read(Object buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		read(handle, buf, db, off, count, type.handle, type.baseType, status.data);
-		return status;
-	}
-
-	private native void read(
-			long fh, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_ALL}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readAll(Object buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		readAll(handle, buf,db,off, count, type.handle, type.baseType, status.data);
-		return status;
-	}
-
-	private native void readAll(
-			long fh, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status write(Object buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		write(handle, buf, db, off, count, type.handle, type.baseType, status.data);
-		return status;
-	}
-
-	private native void write(
-			long fh, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_ALL}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeAll(Object buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		writeAll(handle, buf,db,off, count, type.handle,type.baseType, status.data);
-		return status;
-	}
-
-	private native void writeAll(
-			long fh, Object buf, boolean db, int offset,
-			int count, long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IREAD}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iRead(Buffer buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iRead(handle, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iRead(long fh, Buffer buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IREAD_ALL}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iReadAll(Buffer buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iReadAll(handle, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iReadAll(long fh, Buffer buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IWRITE}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iWrite(Buffer buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iWrite(handle, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iWrite(long fh, Buffer buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IWRITE_ALL}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iWriteAll(Buffer buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iWriteAll(handle, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iWriteAll(long fh, Buffer buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_SEEK}.
-	 * @param offset file offset
-	 * @param whence update mode
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void seek(long offset, int whence) throws MPIException
-	{
-		MPI.check();
-		seek(handle, offset, whence);
-	}
-
-	private native void seek(long fh, long offset, int whence) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_POSITION}.
-	 * @return offset of individual pointer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public long getPosition() throws MPIException
-	{
-		MPI.check();
-		return getPosition(handle);
-	}
-
-	private native long getPosition(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_BYTE_OFFSET}.
-	 * @param offset offset
-	 * @return absolute byte position of offset
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public long getByteOffset(long offset) throws MPIException
-	{
-		MPI.check();
-		return getByteOffset(handle, offset);
-	}
-
-	private native long getByteOffset(long fh, long offset) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_SHARED}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readShared(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		readShared(handle, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void readShared(
-			long fh, Object buf, boolean db, int offset, int count,
-			long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_SHARED}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeShared(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		writeShared(handle, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void writeShared(
-			long fh, Object buf, boolean db, int offset, int count,
-			long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IREAD_SHARED}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iReadShared(Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iReadShared(handle, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iReadShared(long fh, Buffer buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_IWRITE_SHARED}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request iWriteShared(Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(iWriteShared(handle, buf, count, type.handle));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iWriteShared(long fh, Buffer buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_ORDERED}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readOrdered(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		readOrdered(handle, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void readOrdered(
-			long fh, Object buf, boolean db, int offset, int count,
-			long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_ORDERED}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeOrdered(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		writeOrdered(handle, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native void writeOrdered(
-			long fh, Object buf, boolean db, int offset, int count,
-			long type, int baseType, long[] stat) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_SEEK_SHARED}.
-	 * @param offset file offset
-	 * @param whence update mode
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void seekShared(long offset, int whence) throws MPIException
-	{
-		MPI.check();
-		seekShared(handle, offset, whence);
-	}
-
-	private native void seekShared(long fh, long offset, int whence)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_POSITION_SHARED}.
-	 * @return offset of individual pointer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public long getPositionShared() throws MPIException
-	{
-		MPI.check();
-		return getPositionShared(handle);
-	}
-
-	private native long getPositionShared(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_AT_ALL_BEGIN}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void readAtAllBegin(long offset, Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			readAtAllBegin(handle, offset, buf, count, type.handle);
-		}
-		else
-		{
-			int off = 0;
-			Status status = new Status();
-
-			if(isHeapBuffer(buf))
-			{
-				off = type.getOffset(buf);
-				buf = ((Buffer)buf).array();
-			}
-
-			readAtAll(handle, offset, buf, false, off, count,
-					type.handle, type.baseType, status.data);
-
-			beginStatus = status;
-		}
-	}
-
-	private native void readAtAllBegin(
-			long fh, long offset, Object buf, int count, long type)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_AT_ALL_END}.
-	 * @param buf buffer
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readAtAllEnd(Object buf) throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			Status status = new Status();
-			readAtAllEnd(handle, buf, status.data);
-			return status;
-		}
-		else
-		{
-			return getBeginStatus();
-		}
-	}
-
-	private native void readAtAllEnd(long fh, Object buf, long[] stat)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_AT_ALL_BEGIN}.
-	 * @param offset file offset
-	 * @param buf    buffer
-	 * @param count  number of items in buffer
-	 * @param type   datatype of each buffer element
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void writeAtAllBegin(long offset, Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			writeAtAllBegin(handle, offset, buf, count, type.handle);
-		}
-		else
-		{
-			int off = 0;
-			Status status = new Status();
-
-			if(isHeapBuffer(buf))
-			{
-				off = type.getOffset(buf);
-				buf = ((Buffer)buf).array();
-			}
-
-			writeAtAll(handle, offset, buf, false, off, count,
-					type.handle, type.baseType, status.data);
-
-			beginStatus = status;
-		}
-	}
-
-	private native void writeAtAllBegin(
-			long fh, long fileOffset, Object buf, int count, long type)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_AT_ALL_END}.
-	 * @param buf buffer
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeAtAllEnd(Object buf) throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			Status status = new Status();
-			writeAtAllEnd(handle, buf, status.data);
-			return status;
-		}
-		else
-		{
-			return getBeginStatus();
-		}
-	}
-
-	private native void writeAtAllEnd(long fh, Object buf, long[] stat)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_ALL_BEGIN}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void readAllBegin(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			readAllBegin(handle, buf, count, type.handle);
-		}
-		else
-		{
-			int off = 0;
-			Status status = new Status();
-
-			if(isHeapBuffer(buf))
-			{
-				off = type.getOffset(buf);
-				buf = ((Buffer)buf).array();
-			}
-
-			readAll(handle, buf, false, off, count,
-					type.handle, type.baseType, status.data);
-
-			beginStatus = status;
-		}
-	}
-
-	private native void readAllBegin(long fh, Object buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_ALL_END}.
-	 * @param buf buffer
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readAllEnd(Object buf) throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			Status status = new Status();
-			readAllEnd(handle, buf, status.data);
-			return status;
-		}
-		else
-		{
-			return getBeginStatus();
-		}
-	}
-
-	private native void readAllEnd(long fh, Object buf, long[] stat)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_ALL_BEGIN}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void writeAllBegin(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			writeAllBegin(handle, buf, count, type.handle);
-		}
-		else
-		{
-			int off = 0;
-			Status status = new Status();
-
-			if(isHeapBuffer(buf))
-			{
-				off = type.getOffset(buf);
-				buf = ((Buffer)buf).array();
-			}
-
-			writeAll(handle, buf, false, off, count,
-					type.handle, type.baseType, status.data);
-
-			beginStatus = status;
-		}
-	}
-
-	private native void writeAllBegin(long fh, Object buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_ALL_END}.
-	 * @param buf buffer
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeAllEnd(Object buf) throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			Status status = new Status();
-			writeAllEnd(handle, buf, status.data);
-			return status;
-		}
-		else
-		{
-			return getBeginStatus();
-		}
-	}
-
-	private native void writeAllEnd(long fh, Object buf, long[] stat)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_ORDERED_BEGIN}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void readOrderedBegin(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			readOrderedBegin(handle, buf, count, type.handle);
-		}
-		else
-		{
-			int off = 0;
-			Status status = new Status();
-
-			if(isHeapBuffer(buf))
-			{
-				off = type.getOffset(buf);
-				buf = ((Buffer)buf).array();
-			}
-
-			readOrdered(handle, buf, false, off, count,
-					type.handle, type.baseType, status.data);
-
-			beginStatus = status;
-		}
-	}
-
-	private native void readOrderedBegin(long fh, Object buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_READ_ORDERED_END}.
-	 * @param buf buffer
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status readOrderedEnd(Object buf) throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			Status status = new Status();
-			readOrderedEnd(handle, buf, status.data);
-			return status;
-		}
-		else
-		{
-			return getBeginStatus();
-		}
-	}
-
-	private native void readOrderedEnd(long fh, Object buf, long[] stat)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_ORDERED_BEGIN}.
-	 * @param buf   buffer
-	 * @param count number of items in buffer
-	 * @param type  datatype of each buffer element
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void writeOrderedBegin(Object buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			writeOrderedBegin(handle, buf, count, type.handle);
-		}
-		else
-		{
-			int off = 0;
-			Status status = new Status();
-
-			if(isHeapBuffer(buf))
-			{
-				off = type.getOffset(buf);
-				buf = ((Buffer)buf).array();
-			}
-
-			writeOrdered(handle, buf, false, off, count,
-					type.handle, type.baseType, status.data);
-
-			beginStatus = status;
-		}
-	}
-
-	private native void writeOrderedBegin(long fh, Object buf, int count, long type)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_WRITE_ORDERED_END}.
-	 * @param buf buffer
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status writeOrderedEnd(Object buf) throws MPIException
-	{
-		MPI.check();
-
-		if(isDirectBuffer(buf))
-		{
-			Status status = new Status();
-			writeOrderedEnd(handle, buf, status.data);
-			return status;
-		}
-		else
-		{
-			return getBeginStatus();
-		}
-	}
-
-	private native void writeOrderedEnd(long fh, Object buf, long[] stat)
-			throws MPIException;
-
-	private Status getBeginStatus()
-	{
-		Status s = beginStatus;
-		beginStatus = null;
-		return s;
-	}
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_TYPE_EXTENT}.
-	 * @param type		type of data
-	 * @return datatype extent
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getTypeExtent(Datatype type) throws MPIException
-	{
-		MPI.check();
-		return getTypeExtent(handle, type.handle) / type.baseSize;
-	}
-
-	private native int getTypeExtent(long fh, long type) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_SET_ATOMICITY}.
-	 * @param atomicity true to set atomic mode, false to set nonatomic mode
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setAtomicity(boolean atomicity) throws MPIException
-	{
-		MPI.check();
-		setAtomicity(handle, atomicity);
-	}
-
-	private native void setAtomicity(long fh, boolean atomicity)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_GET_ATOMICITY}.
-	 * @return current consistency of the file
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public boolean getAtomicity() throws MPIException
-	{
-		MPI.check();
-		return getAtomicity(handle);
-	}
-
-	private native boolean getAtomicity(long fh) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FILE_SYNC}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void sync() throws MPIException
-	{
-		MPI.check();
-		sync(handle);
-	}
-
-	private native void sync(long handle) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_FILE_SET_ERRHANDLER}.
-	 * @param errhandler new MPI error handler for file
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setErrhandler(Errhandler errhandler) throws MPIException
-	{
-		MPI.check();
-		setErrhandler(handle, errhandler.handle);
-	}
-
-	private native void setErrhandler(long fh, long errhandler)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_FILE_GET_ERRHANDLER}.
-	 * @return MPI error handler currently associated with file
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Errhandler getErrhandler() throws MPIException
-	{
-		MPI.check();
-		return new Errhandler(getErrhandler(handle));
-	}
-
-	private native long getErrhandler(long fh);
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_FILE_CALL_ERRHANDLER}.
-	 * @param errorCode error code
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void callErrhandler(int errorCode) throws MPIException
-	{
-		callErrhandler(handle, errorCode);
-	}
-
-	private native void callErrhandler(long handle, int errorCode)
-			throws MPIException;
-
-} // File
diff --git a/ompi/mpi/java/java/FileView.java b/ompi/mpi/java/java/FileView.java
deleted file mode 100644
index cb791056c42..00000000000
--- a/ompi/mpi/java/java/FileView.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * This class represents file views.
- */
-public final class FileView
-{
-	private final long disp;
-	private final Datatype etype, filetype;
-	private final String datarep;
-
-	/**
-	 * Constructs a file view.
-	 * @param disp     displacement
-	 * @param etype    elementary datatype
-	 * @param filetype file type
-	 * @param datarep  data representation
-	 */
-	public FileView(long disp, Datatype etype, Datatype filetype, String datarep)
-	{
-		this.disp     = disp;
-		this.etype    = etype;
-		this.filetype = filetype;
-		this.datarep  = datarep;
-	}
-
-	/**
-	 * Gets the displacement.
-	 * @return displacement
-	 */
-	public long getDisp()
-	{
-		return disp;
-	}
-
-	/**
-	 * Gets the elementary datatype.
-	 * @return elementary datatype
-	 */
-	public Datatype getEType()
-	{
-		return etype;
-	}
-
-	/**
-	 * Gets the file type.
-	 * @return file type
-	 */
-	public Datatype getFileType()
-	{
-		return filetype;
-	}
-
-	/**
-	 * Gets the data representation.
-	 * @return data representation
-	 */
-	public String getDataRep()
-	{
-		return datarep;
-	}
-
-} // FileView
diff --git a/ompi/mpi/java/java/FloatComplex.java b/ompi/mpi/java/java/FloatComplex.java
deleted file mode 100644
index 572f1d6fb30..00000000000
--- a/ompi/mpi/java/java/FloatComplex.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-import java.nio.*;
-
-/**
- * This class wraps a complex number stored in a buffer.
- */
-public final class FloatComplex
-{
-	private final int offset;
-	private final FloatBuffer buffer;
-
-	private FloatComplex(FloatBuffer buffer, int index)
-	{
-		this.buffer = buffer;
-		this.offset = index * 2;
-	}
-
-	/**
-	 * Wraps a complex number stored in a buffer
-	 * @param buffer buffer
-	 * @return complex number
-	 */
-	public static FloatComplex get(FloatBuffer buffer)
-	{
-		return new FloatComplex(buffer, 0);
-	}
-
-	/**
-	 * Wraps the complex number at the specified position
-	 * of an array of complex numbers stored in a buffer.
-	 * @param buffer buffer
-	 * @param index  index
-	 * @return complex number
-	 */
-	public static FloatComplex get(FloatBuffer buffer, int index)
-	{
-		return new FloatComplex(buffer, index);
-	}
-
-	/**
-	 * Wraps a complex number stored in the first two values of an array.
-	 * @param  array array
-	 * @return complex number
-	 */
-	public static FloatComplex get(float[] array)
-	{
-		return new FloatComplex(FloatBuffer.wrap(array), 0);
-	}
-
-	/**
-	 * Wraps the complex number at the specified position of
-	 * an array of complex numbers stored in an array of floats.
-	 * @param array array
-	 * @param index index
-	 * @return complex number
-	 */
-	public static FloatComplex get(float[] array, int index)
-	{
-		return new FloatComplex(FloatBuffer.wrap(array), index);
-	}
-
-	/**
-	 * Wraps a complex number stored in a buffer
-	 * @param buffer buffer
-	 * @return complex number
-	 */
-	public static FloatComplex get(ByteBuffer buffer)
-	{
-		return new FloatComplex(buffer.asFloatBuffer(), 0);
-	}
-
-	/**
-	 * Wraps the complex number at the specified position
-	 * of an array of complex numbers stored in a buffer.
-	 * @param buffer buffer
-	 * @param index  index
-	 * @return complex number
-	 */
-	public static FloatComplex get(ByteBuffer buffer, int index)
-	{
-		return new FloatComplex(buffer.asFloatBuffer(), index);
-	}
-
-	/**
-	 * Gets the real value.
-	 * @return real value
-	 */
-	public float getReal()
-	{
-		return buffer.get(offset);
-	}
-
-	/**
-	 * Gets the imaginary value.
-	 * @return imaginary value.
-	 */
-	public float getImag()
-	{
-		return buffer.get(offset + 1);
-	}
-
-	/**
-	 * Puts the real value.
-	 * @param real real value
-	 */
-	public void putReal(float real)
-	{
-		buffer.put(offset, real);
-	}
-
-	/**
-	 * Puts the imaginary value.
-	 * @param imag imaginary value
-	 */
-	public void putImag(float imag)
-	{
-		buffer.put(offset + 1, imag);
-	}
-
-	/**
-	 * Gets the buffer where the complex number is stored.
-	 * @return buffer where the complex number is stored
-	 */
-	public FloatBuffer getBuffer()
-	{
-		return offset == 0 ? buffer : MPI.slice(buffer, offset);
-	}
-
-} // FloatComplex
diff --git a/ompi/mpi/java/java/FloatInt.java b/ompi/mpi/java/java/FloatInt.java
deleted file mode 100644
index 1eb55bde76c..00000000000
--- a/ompi/mpi/java/java/FloatInt.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * Struct class for {@link MPI#FLOAT_INT} datatype.
- */
-public final class FloatInt extends Struct
-{
-	private final int iOff, iSize;
-
-	/**
-	 * The struct object will be created only in MPI class.
-	 * @param intOff	int offset
-	 * @param intSize	int size
-	 * @see MPI#floatInt
-	 */
-	protected FloatInt(int intOff, int intSize)
-	{
-		int fOff = addFloat();
-		assert fOff == 0;
-
-		iSize = intSize;
-		setOffset(intOff);
-
-		switch(iSize)
-		{
-		case 4: iOff = addInt();  break;
-		case 8: iOff = addLong(); break;
-		default: throw new AssertionError("Unsupported int size: "+ iSize);
-		}
-
-		assert(intOff == iOff);
-	}
-
-	/**
-	 * Creates a Data object.
-	 * @return new Data object.
-	 */
-	@Override protected Data newData()
-	{
-		return new Data();
-	}
-
-	/**
-	 * Class for reading/writing data in a struct stored in a byte buffer.
-	 */
-	public final class Data extends Struct.Data
-	{
-		/**
-		 * Gets the float value.
-		 * @return float value
-		 */
-		public float getValue()
-		{
-			return getFloat(0);
-		}
-
-		/**
-		 * Gets the int value.
-		 * @return int value
-		 */
-		public int getIndex()
-		{
-			switch(iSize)
-			{
-			case 4: return getInt(iOff);
-			case 8: return (int)getLong(iOff);
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Puts the float value.
-		 * @param v float value
-		 */
-		public void putValue(float v)
-		{
-			putFloat(0, v);
-		}
-
-		/**
-		 * Puts the int value.
-		 * @param v int value
-		 */
-		public void putIndex(int v)
-		{
-			switch(iSize)
-			{
-			case 4: putInt(iOff, v);  break;
-			case 8: putLong(iOff, v); break;
-			default: throw new AssertionError();
-			}
-		}
-	} // Data
-
-} // FloatInt
diff --git a/ompi/mpi/java/java/Freeable.java b/ompi/mpi/java/java/Freeable.java
deleted file mode 100644
index 736a729fee1..00000000000
--- a/ompi/mpi/java/java/Freeable.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Freeable.java
- * Author       : Bryan Carpenter
- * Created      : Wed Jan 15 23:14:43 EST 2003
- * Revision     : $Revision: 1.1 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- */
-
-package mpi;
-
-/**
- * Objects freeables must be freed calling the method free.
- */
-public interface Freeable
-{
-	/**
-	 * Frees a freeable object.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	void free() throws MPIException;
-}
-
diff --git a/ompi/mpi/java/java/GraphComm.java b/ompi/mpi/java/java/GraphComm.java
deleted file mode 100644
index 8ee75c2459a..00000000000
--- a/ompi/mpi/java/java/GraphComm.java
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Graphcomm.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.5 $
- * Updated      : $Date: 2001/10/22 21:07:55 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * Communicator with graph structure.
- */
-public final class GraphComm extends Intracomm
-{
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	protected GraphComm(long handle) throws MPIException
-	{
-		super(handle);
-	}
-
-	protected GraphComm(long[] commRequest)
-	{
-		super(commRequest);
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * <p>It is recommended to use {@link #dup} instead of {@link #clone}
-	 * because the last can't throw an {@link mpi.MPIException}.
-	 * @return copy of this communicator
-	 */
-	@Override public GraphComm clone()
-	{
-		try
-		{
-			return dup();
-		}
-		catch(MPIException e)
-		{
-			throw new RuntimeException(e.getMessage());
-		}
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public GraphComm dup() throws MPIException
-	{
-		MPI.check();
-		return new GraphComm(dup(handle));
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>The new communicator can't be used before the operation completes.
-	 * The request object must be obtained calling {@link #getRequest}.
-	 * <p>Java binding of {@code MPI_COMM_IDUP}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public GraphComm iDup() throws MPIException
-	{
-		MPI.check();
-		return new GraphComm(iDup(handle));
-	}
-
-	/**
-	* Duplicates this communicator with the info object used in the call.
-	* <p>Java binding of {@code MPI_COMM_DUP_WITH_INFO}.
-	* @param info	info object to associate with the new communicator
-	* @return copy of this communicator
-	* @throws MPIException Signals that an MPI error of some sort has occurred.
-	*/
-	@Override public GraphComm dupWithInfo(Info info) throws MPIException
-	{
-	    MPI.check();
-	    return new GraphComm(dupWithInfo(handle, info.handle));
-	}
-
-	/**
-	 * Returns graph topology information.
-	 * <p>Java binding of the MPI operations {@code MPI_GRAPHDIMS_GET}
-	 * and {@code MPI_GRAPH_GET}.
-	 * <p>The number of nodes and number of edges can be extracted
-	 * from the sizes of the {@code index} and {@code edges} fields
-	 * of the returned object.
-	 * @return object defining node degrees and edges of graph
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public GraphParms getDims() throws MPIException
-	{
-		MPI.check();
-		return getDims(handle);
-	}
-
-	private native GraphParms getDims(long comm) throws MPIException;
-
-	/**
-	 * Provides adjacency information for general graph topology.
-	 * <p>Java binding of the MPI operations {@code MPI_GRAPH_NEIGHBORS_COUNT}
-	 * and {@code MPI_GRAPH_NEIGHBORS}.
-	 * <p>The number of neighbors can be extracted from the size of the result.
-	 * @param rank rank of a process in the group of this communicator
-	 * @return array of ranks of neighboring processes to one specified
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int[] getNeighbors(int rank) throws MPIException
-	{
-		MPI.check();
-		return getNeighbors(handle, rank);
-	}
-
-	private native int[] getNeighbors(long comm, int rank) throws MPIException;
-
-	/**
-	 * Gets the adjacency information for a distributed graph topology.
-	 * @return adjacency information for a distributed graph topology
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public DistGraphNeighbors getDistGraphNeighbors() throws MPIException
-	{
-		MPI.check();
-		return getDistGraphNeighbors(handle);
-	}
-
-	private native DistGraphNeighbors getDistGraphNeighbors(long comm)
-			throws MPIException;
-
-	/**
-	 * Compute an optimal placement.
-	 * <p>Java binding of the MPI operation {@code MPI_GRAPH_MAP}.
-	 * <p>The number of nodes is taken to be size of the {@code index} argument.
-	 * @param index node degrees
-	 * @param edges graph edges
-	 * @return reordered rank of calling process
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int map(int[] index, int[] edges) throws MPIException
-	{
-		MPI.check();
-		return map(handle, index, edges);
-	}
-
-	private native int map(long comm, int[] index, int[] edges) throws MPIException;
-
-} // Graphcomm
diff --git a/ompi/mpi/java/java/GraphParms.java b/ompi/mpi/java/java/GraphParms.java
deleted file mode 100644
index 49dc5b1a789..00000000000
--- a/ompi/mpi/java/java/GraphParms.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : GraphParms.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.1 $
- * Updated      : $Date: 1998/08/26 18:49:55 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * Graph topology information associated with a communicator.
- */
-public final class GraphParms
-{
-	/** Node degrees. */
-	private final int[] index;
-
-	/** Graph edges. */
-	private final int[] edges;
-
-	/**
-	 * Constructs a graph topology information object.
-	 * @param index node degrees.
-	 * @param edges graph edges.
-	 */
-	protected GraphParms(int[] index, int[] edges)
-	{
-		this.index = index;
-		this.edges = edges;
-	}
-
-	/**
-	 * Returns the number of nodes.
-	 * @return number of nodes.
-	 */
-	public int getIndexCount()
-	{
-		return index.length;
-	}
-
-	/**
-	 * Returns the index of the node {@code i}.
-	 * <p>{@code getIndex(0)} returns the degree of the node {@code 0}, and
-	 * {@code getIndex(i)-getIndex(i-1)} is the degree of the node {@code i}.
-	 * @param i position of the node.
-	 * @return the index.
-	 */
-	public int getIndex(int i)
-	{
-		return index[i];
-	}
-
-	/**
-	 * Returns the number of edges.
-	 * @return number of edges.
-	 */
-	public int getEdgeCount()
-	{
-		return edges.length;
-	}
-
-	/**
-	 * Returns the edge {@code i}.
-	 * <p>The list of neighbors of node zero is stored in {@code getEdge(j)},
-	 * for {@code 0} &le; {@code j} &le; {@code getIndex(0)-1} and the list
-	 * of neighbors of node {@code i}, {@code i} &gt; {@code 0}, is stored
-	 * in {@code getEdge(j)}, {@code getIndex(i-1)} &le; {@code j} &le;
-	 * {@code getIndex(i)-1}.
-	 * @param i index of the edge.
-	 * @return the edge.
-	 */
-	public int getEdge(int i)
-	{
-		return edges[i];
-	}
-
-} // GraphParms
diff --git a/ompi/mpi/java/java/Group.java b/ompi/mpi/java/java/Group.java
deleted file mode 100644
index 254af2100fb..00000000000
--- a/ompi/mpi/java/java/Group.java
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Group.java
- * Author       : Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.8 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * This class represents {@code MPI_Group}.
- */
-public final class Group implements Freeable
-{
-	protected long handle;
-	private static long nullHandle;
-
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	protected static native long getEmpty();
-
-	protected Group(long handle)
-	{
-		this.handle = handle;
-	}
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_GROUP_SIZE}.
-	 * @return number of processes in the group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getSize() throws MPIException
-	{
-		MPI.check();
-		return getSize(handle);
-	}
-
-	private native int getSize(long group) throws MPIException;
-
-	/**
-	 * Rank of this process in the group.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_RANK}.
-	 * @return rank of this process in the group, or {@code MPI.UNDEFINED}
-	 *         if this process is not a member of the group.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getRank() throws MPIException
-	{
-		MPI.check();
-		return getRank(handle);
-	}
-
-	private native int getRank(long group) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_GROUP_FREE}.
-	 */
-	@Override public void free() throws MPIException
-	{
-		MPI.check();
-		handle = free(handle);
-	}
-
-	private native long free(long group);
-
-	/**
-	 * Test if group object is null.
-	 * @return true if the group object is null.
-	 */
-	public boolean isNull()
-	{
-		return handle == nullHandle;
-	}
-
-	/**
-	 * Translate ranks within one group to ranks within another.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_TRANSLATE_RANKS}.
-	 * <p>Result elements are {@code MPI.UNDEFINED} where no correspondence exists.
-	 * @param group1 a group
-	 * @param ranks1 array of valid ranks in group1
-	 * @param group2 another group
-	 * @return array of corresponding ranks in group2
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int[] translateRanks(Group group1, int[] ranks1, Group group2)
-			throws MPIException
-	{
-		MPI.check();
-		return translateRanks(group1.handle, ranks1, group2.handle);
-	}
-
-	private static native int[] translateRanks(
-			long group1, int[] ranks1, long group2) throws MPIException;
-
-	/**
-	 * Compare two groups.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_COMPARE}.
-	 * @param group1 first group
-	 * @param group2 second group
-	 * @return {@code MPI.IDENT} if the group members and group order are exactly
-	 *         the same in both groups, {@code MPI.SIMILAR} if the group members are
-	 *         the same but the order is different, {@code MPI.UNEQUAL} otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int compare(Group group1, Group group2) throws MPIException
-	{
-		MPI.check();
-		return compare(group1.handle, group2.handle);
-	}
-
-	private static native int compare(long group1, long group2) throws MPIException;
-
-	/**
-	 * Set union of two groups.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_UNION}.
-	 * @param group1 first group
-	 * @param group2 second group
-	 * @return union group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Group union(Group group1, Group group2) throws MPIException
-	{
-		MPI.check();
-		return new Group(union(group1.handle, group2.handle));
-	}
-
-	private static native long union(long group1, long group2);
-
-	/**
-	 * Set intersection of two groups.
-	 * Java binding of the MPI operation {@code MPI_GROUP_INTERSECTION}.
-	 * @param group1 first group
-	 * @param group2 second group
-	 * @return intersection group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Group intersection(Group group1, Group group2) throws MPIException
-	{
-		MPI.check();
-		return new Group(intersection(group1.handle, group2.handle));
-	}
-
-	private static native long intersection(long group1, long group2);
-
-	/**
-	 * Set difference of two groups.
-	 * Java binding of the MPI operation {@code MPI_GROUP_DIFFERENCE}.
-	 * @param group1 first group
-	 * @param group2 second group
-	 * @return difference group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Group difference(Group group1, Group group2) throws MPIException
-	{
-		MPI.check();
-		return new Group(difference(group1.handle, group2.handle));
-	}
-
-	private static native long difference(long group1, long group2);
-
-	/**
-	 * Create a subset group including specified processes.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_INCL}.
-	 * @param ranks ranks from this group to appear in new group
-	 * @return new group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Group incl(int[] ranks) throws MPIException
-	{
-		MPI.check();
-		return new Group(incl(handle, ranks));
-	}
-
-	private native long incl(long group, int[] ranks);
-
-	/**
-	 * Create a subset group excluding specified processes.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_EXCL}.
-	 * @param ranks ranks from this group <em>not</em> to appear in new group
-	 * @return new group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Group excl(int[] ranks) throws MPIException
-	{
-		MPI.check();
-		return new Group(excl(handle, ranks));
-	}
-
-	private native long excl(long group, int[] ranks);
-
-	/**
-	 * Create a subset group including processes specified
-	 * by strided intervals of ranks.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_RANGE_INCL}.
-	 * <p>The triplets are of the form (first rank, last rank, stride)
-	 * indicating ranks in this group to be included in the new group.
-	 * The size of the first dimension of {@code ranges} is the number
-	 * of triplets.  The size of the second dimension is 3.
-	 * @param ranges array of integer triplets
-	 * @return new group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Group rangeIncl(int[][] ranges) throws MPIException
-	{
-		MPI.check();
-		return new Group(rangeIncl(handle, ranges));
-	}
-
-	private native long rangeIncl(long group, int[][] ranges);
-
-	/**
-	 * Create a subset group excluding processes specified
-	 * by strided intervals of ranks.
-	 * <p>Java binding of the MPI operation {@code MPI_GROUP_RANGE_EXCL}.
-	 * <p>Triplet array is defined as for {@code rangeIncl}, the ranges
-	 * indicating ranks in this group to be excluded from the new group.
-	 * @param ranges array of integer triplets
-	 * @return new group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Group rangeExcl(int[][] ranges) throws MPIException
-	{
-		MPI.check();
-		return new Group(rangeExcl(handle, ranges));
-	}
-
-	private native long rangeExcl(long group, int[][] ranges);
-
-} // Group
diff --git a/ompi/mpi/java/java/Info.java b/ompi/mpi/java/java/Info.java
deleted file mode 100644
index 0579f123868..00000000000
--- a/ompi/mpi/java/java/Info.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * This class represents {@code MPI_Info}.
- */
-public final class Info implements Freeable, Cloneable
-{
-	protected long handle;
-	protected static final long NULL = getNull();
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_CREATE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Info() throws MPIException
-	{
-		MPI.check();
-		handle = create();
-	}
-
-	protected Info(long handle)
-	{
-		this.handle = handle;
-	}
-
-	private native long create();
-
-	protected static Info newEnv()
-	{
-		return new Info(getEnv());
-	}
-
-	private native static long getEnv();
-	private native static long getNull();
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_SET}.
-	 * @param key   key
-	 * @param value value
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void set(String key, String value) throws MPIException
-	{
-		MPI.check();
-		set(handle, key, value);
-	}
-
-	private native void set(long handle, String key, String value)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_GET}.
-	 * @param key key
-	 * @return value or {@code null} if key is not defined
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public String get(String key) throws MPIException
-	{
-		MPI.check();
-		return get(handle, key);
-	}
-
-	private native String get(long handle, String key) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_DELETE}.
-	 * @param key key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void delete(String key) throws MPIException
-	{
-		MPI.check();
-		delete(handle, key);
-	}
-
-	private native void delete(long handle, String key) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_GET_NKEYS}.
-	 * @return number of defined keys
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int size() throws MPIException
-	{
-		MPI.check();
-		return size(handle);
-	}
-
-	private native int size(long handle) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_GET_NTHKEY}.
-	 * @param i key number
-	 * @return key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public String getKey(int i) throws MPIException
-	{
-		MPI.check();
-		return getKey(handle, i);
-	}
-
-	private native String getKey(long handle, int i) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_DUP}.
-	 * <p>It is recommended to use {@link #dup} instead of {@link #clone}
-	 * because the last can't throw an {@link mpi.MPIException}.
-	 * @return info object
-	 */
-	@Override public Info clone()
-	{
-		try
-		{
-			return dup();
-		}
-		catch(MPIException e)
-		{
-			throw new RuntimeException(e.getMessage());
-		}
-	}
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_DUP}.
-	 * @return info object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Info dup() throws MPIException
-	{
-		MPI.check();
-		return new Info(dup(handle));
-	}
-
-	private native long dup(long handle) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_INFO_FREE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public void free() throws MPIException
-	{
-		MPI.check();
-		handle = free(handle);
-	}
-
-	private native long free(long handle) throws MPIException;
-
-	/**
-	 * Tests if the info object is {@code MPI_INFO_NULL} (has been freed).
-	 * @return true if the info object is {@code MPI_INFO_NULL}, false otherwise.
-	 */
-	public boolean isNull()
-	{
-		return isNull(handle);
-	}
-
-	private native boolean isNull(long handle);
-
-} // Info
diff --git a/ompi/mpi/java/java/Int2.java b/ompi/mpi/java/java/Int2.java
deleted file mode 100644
index 0ba594d65cf..00000000000
--- a/ompi/mpi/java/java/Int2.java
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * Struct class for {@link MPI#INT2} datatype.
- */
-public final class Int2 extends Struct
-{
-	private final int iOff, iSize;
-
-	/**
-	 * The struct object will be created only in MPI class.
-	 * @param intOff	int offset
-	 * @param intSize	int size
-	 * @see MPI#int2
-	 */
-	protected Int2(int intOff, int intSize)
-	{
-		iSize = intSize;
-		int off = addIntField();
-		assert off == 0;
-		setOffset(intOff);
-		iOff = addIntField();
-		assert intOff == iOff;
-	}
-
-	private int addIntField()
-	{
-		switch(iSize)
-		{
-		case 4: return addInt();
-		case 8: return addLong();
-		default: throw new AssertionError("Unsupported int size: "+ iSize);
-		}
-	}
-
-	/**
-	 * Creates a Data object.
-	 * @return new Data object.
-	 */
-	@Override protected Int2.Data newData()
-	{
-		return new Int2.Data();
-	}
-
-	/**
-	 * Class for reading/writing data in a struct stored in a byte buffer.
-	 */
-	public final class Data extends Struct.Data
-	{
-		/**
-		 * Gets the first int.
-		 * @return first int
-		 */
-		public int getValue()
-		{
-			return get(0);
-		}
-
-		/**
-		 * Gets the second int.
-		 * @return second int
-		 */
-		public int getIndex()
-		{
-			return get(iOff);
-		}
-
-		/**
-		 * Puts the first int.
-		 * @param v first value
-		 */
-		public void putValue(int v)
-		{
-			put(0, v);
-		}
-
-		/**
-		 * Puts the second int.
-		 * @param v second int
-		 */
-		public void putIndex(int v)
-		{
-			put(iOff, v);
-		}
-
-		private int get(int off)
-		{
-			switch(iSize)
-			{
-			case 4: return getInt(off);
-			case 8: return (int)getLong(off);
-			default: throw new AssertionError();
-			}
-		}
-
-		private void put(int off, int v)
-		{
-			switch(iSize)
-			{
-			case 4: putInt(off, v);  break;
-			case 8: putLong(off, v); break;
-			default: throw new AssertionError();
-			}
-		}
-	} // Data
-
-} // Int2
diff --git a/ompi/mpi/java/java/Intercomm.java b/ompi/mpi/java/java/Intercomm.java
deleted file mode 100644
index 1cce85e2a80..00000000000
--- a/ompi/mpi/java/java/Intercomm.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Intercomm.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.5 $
- * Updated      : $Date: 1999/09/14 20:50:11 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * This class represents intercommunicators.
- */
-public final class Intercomm extends Comm
-{
-	protected Intercomm(long handle)
-	{
-		super(handle);
-	}
-
-	protected Intercomm(long[] commRequest)
-	{
-		super(commRequest);
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * <p>It is recommended to use {@link #dup} instead of {@link #clone}
-	 * because the last can't throw an {@link mpi.MPIException}.
-	 * @return copy of this communicator
-	 */
-	@Override public Intercomm clone()
-	{
-		try
-		{
-			return dup();
-		}
-		catch(MPIException e)
-		{
-			throw new RuntimeException(e.getMessage());
-		}
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public Intercomm dup() throws MPIException
-	{
-		MPI.check();
-		return new Intercomm(dup(handle));
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_IDUP}.
-	 * <p>The new communicator can't be used before the operation completes.
-	 * The request object must be obtained calling {@link #getRequest}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public Intercomm iDup() throws MPIException
-	{
-		MPI.check();
-		return new Intercomm(iDup(handle));
-	}
-
-	/**
-	* Duplicates this communicator with the info object used in the call.
-	* <p>Java binding of {@code MPI_COMM_DUP_WITH_INFO}.
-	* @param info	info object to associate with the new communicator
-	* @return copy of this communicator
-	* @throws MPIException Signals that an MPI error of some sort has occurred.
-	*/
-	@Override public Intercomm dupWithInfo(Info info) throws MPIException
-	{
-	    MPI.check();
-	    return new Intercomm(dupWithInfo(handle, info.handle));
-	}
-
-	// Inter-Communication
-
-	/**
-	 * Size of remote group.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_REMOTE_SIZE}.
-	 * @return number of process in remote group of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getRemoteSize() throws MPIException
-	{
-		MPI.check();
-		return getRemoteSize_jni();
-	}
-
-	private native int getRemoteSize_jni() throws MPIException;
-
-	/**
-	 * Return the remote group.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_REMOTE_GROUP}.
-	 * @return remote group of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Group getRemoteGroup() throws MPIException
-	{
-		MPI.check();
-		return new Group(getRemoteGroup_jni());
-	}
-
-	private native long getRemoteGroup_jni();
-
-	/**
-	 * Creates an intracommuncator from an intercommunicator
-	 * <p>Java binding of the MPI operation {@code MPI_INTERCOMM_MERGE}.
-	 * @param high true if the local group has higher ranks in combined group
-	 * @return new intra-communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Intracomm merge(boolean high) throws MPIException
-	{
-		MPI.check();
-		return new Intracomm(merge_jni(high));
-	}
-
-	private native long merge_jni(boolean high);
-
-	/**
-	 * Java binding of {@code MPI_COMM_GET_PARENT}.
-	 * @return the parent communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Intercomm getParent() throws MPIException
-	{
-		MPI.check();
-		return new Intercomm(getParent_jni());
-	}
-
-	private native static long getParent_jni() throws MPIException;
-
-} // Intercomm
diff --git a/ompi/mpi/java/java/Intracomm.java b/ompi/mpi/java/java/Intracomm.java
deleted file mode 100644
index 95decb25ef0..00000000000
--- a/ompi/mpi/java/java/Intracomm.java
+++ /dev/null
@@ -1,887 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Intracommm.java
- * Author       : Sang Lim, Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.14 $
- * Updated      : $Date: 2002/12/16 15:25:13 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- *
- *
- *
- * IMPLEMENTATION DETAILS
- *
- * All methods with buffers that can be direct or non direct have
- * a companion argument 'db' which is true if the buffer is direct.
- * For example, if the buffer argument is recvBuf, the companion
- * argument will be 'rdb', meaning if the receive buffer is direct.
- *
- * Checking if a buffer is direct is faster in Java than C.
- */
-package mpi;
-
-import java.nio.*;
-import static mpi.MPI.assertDirectBuffer;
-
-/**
- * This class represents intracommunicator.
- */
-public class Intracomm extends Comm
-{
-	protected Intracomm()
-	{
-	}
-
-	protected Intracomm(long handle)
-	{
-		super(handle);
-	}
-
-	protected Intracomm(long[] commRequest)
-	{
-		super(commRequest);
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * <p>It is recommended to use {@link #dup} instead of {@link #clone}
-	 * because the last can't throw an {@link mpi.MPIException}.
-	 * @return copy of this communicator
-	 */
-	@Override public Intracomm clone()
-	{
-		try
-		{
-			return dup();
-		}
-		catch(MPIException e)
-		{
-			throw new RuntimeException(e.getMessage());
-		}
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_DUP}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public Intracomm dup() throws MPIException
-	{
-		MPI.check();
-		return new Intracomm(dup(handle));
-	}
-
-	/**
-	 * Duplicates this communicator.
-	 * <p>Java binding of {@code MPI_COMM_IDUP}.
-	 * <p>The new communicator can't be used before the operation completes.
-	 * The request object must be obtained calling {@link #getRequest}.
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public Intracomm iDup() throws MPIException
-	{
-		MPI.check();
-		return new Intracomm(iDup(handle));
-	}
-
-	/**
-	 * Duplicates this communicator with the info object used in the call.
-	 * <p>Java binding of {@code MPI_COMM_DUP_WITH_INFO}.
-	 * @param info	info object to associate with the new communicator
-	 * @return copy of this communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public Intracomm dupWithInfo(Info info) throws MPIException
-	{
-	    MPI.check();
-	    return new Intracomm(dupWithInfo(handle, info.handle));
-	}
-
-	/**
-	 * Partition the group associated with this communicator and create
-	 * a new communicator within each subgroup.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_SPLIT}.
-	 * @param colour control of subset assignment
-	 * @param key    control of rank assignment
-	 * @return new communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intracomm split(int colour, int key) throws MPIException
-	{
-		MPI.check();
-		return new Intracomm(split(handle, colour, key));
-	}
-
-	private native long split(long comm, int colour, int key) throws MPIException;
-
-	/**
-	 * Partition the group associated with this communicator and create
-	 * a new communicator within each subgroup.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_SPLIT_TYPE}.
-	 * @param splitType	type of processes to be grouped together
-	 * @param key	    control of rank assignment
-	 * @param info		info argument
-	 * @return new communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intracomm splitType(int splitType, int key, Info info) throws MPIException
-	{
-		MPI.check();
-		return new Intracomm(splitType(handle, splitType, key, info.handle));
-	}
-
-	private native long splitType(long comm, int colour, int key, long info) throws MPIException;
-
-	/**
-	 * Create a new communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_CREATE}.
-	 * @param group group which is a subset of the group of this communicator
-	 * @return new communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intracomm create(Group group) throws MPIException
-	{
-		MPI.check();
-		return new Intracomm(create(handle, group.handle));
-	}
-
-	private native long create(long comm, long group);
-
-	/**
-	 * Create a new intracommunicator for the given group.
-	 * <p>Java binding of the MPI operation {@code MPI_COMM_CREATE_GROUP}.
-	 * @param group group which is a subset of the group of this communicator
-	 * @param tag	an integer tag
-	 * @return new communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intracomm createGroup(Group group, int tag) throws MPIException
-	{
-	    MPI.check();
-	    return new Intracomm(createGroup(handle, group.handle, tag));
-	}
-
-	private native long createGroup(long comm, long group, int tag);
-
-	// Topology Constructors
-
-	/**
-	 * Creates a communicator to which the Cartesian topology
-	 * information is attached.
-	 * Create a cartesian topology communicator whose group is a subset
-	 * of the group of this communicator.
-	 * <p>Java binding of the MPI operation {@code MPI_CART_CREATE}.
-	 * <p>The number of dimensions of the Cartesian grid is taken to be the
-	 * size of the {@code dims} argument. The array {@code periods} must
-	 * be the same size.
-	 * @param dims    the number of processes in each dimension
-	 * @param periods {@code true}  if grid is periodic,
-	 *                {@code false} if not, in each dimension
-	 * @param reorder {@code true}  if ranking may be reordered,
-	 *                {@code false} if not
-	 * @return new cartesian topology communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final CartComm createCart(int[] dims, boolean[] periods, boolean reorder)
-			throws MPIException
-	{
-		MPI.check();
-		return new CartComm(createCart(handle, dims, periods, reorder));
-	}
-
-	private native long createCart(
-			long comm, int[] dims, boolean[] periods, boolean reorder)
-					throws MPIException;
-
-	/**
-	 * Creates a communicator to which the graph topology information is attached.
-	 * <p>Java binding of the MPI operation {@code MPI_GRAPH_CREATE}.
-	 * <p>The number of nodes in the graph, <em>nnodes</em>, is taken
-	 * to be size of the {@code index} argument.
-	 * @param index   node degrees
-	 * @param edges   graph edges
-	 * @param reorder {@code true} if ranking may be reordered,
-	 *                {@code false} if not
-	 * @return new graph topology communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final GraphComm createGraph(int[] index, int[] edges, boolean reorder)
-			throws MPIException
-	{
-		MPI.check();
-		return new GraphComm(createGraph(handle, index, edges, reorder));
-	}
-
-	private native long createGraph(
-			long comm, int[] index, int[] edges, boolean reorder)
-					throws MPIException;
-
-	/**
-	 * Creates a communicator to which the distributed graph topology
-	 * information is attached.
-	 * <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE}.
-	 * <p>The number of source nodes is the size of the {@code sources} argument.
-	 * @param sources      source nodes for which this process specifies edges
-	 * @param degrees      number of destinations for each source node
-	 * @param destinations destination nodes for the source nodes
-	 * @param weights      weights for source to destination edges
-	 * @param info         hints on optimization and interpretation of weights
-	 * @param reorder      the process may be reordered (true) or not (false)
-	 * @return communicator with distributed graph topology
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final GraphComm createDistGraph(
-			int[] sources, int[] degrees, int[] destinations,
-			int[] weights, Info info, boolean reorder)
-					throws MPIException
-	{
-		MPI.check();
-
-		return new GraphComm(createDistGraph(
-				handle, sources, degrees, destinations,
-				weights, info.handle, reorder, true));
-	}
-
-	/**
-	 * Creates a communicator to which the distributed graph topology
-	 * information is attached.
-	 * <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE}
-	 * using {@code MPI_UNWEIGHTED}.
-	 * <p>The number of source nodes is the size of the {@code sources} argument.
-	 * @param sources      source nodes for which this process specifies edges
-	 * @param degrees      number of destinations for each source node
-	 * @param destinations destination nodes for the source nodes
-	 * @param info         hints on optimization and interpretation of weights
-	 * @param reorder      the process may be reordered (true) or not (false)
-	 * @return communicator with distributed graph topology
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final GraphComm createDistGraph(
-			int[] sources, int[] degrees, int[] destinations,
-			Info info, boolean reorder)
-					throws MPIException
-	{
-		MPI.check();
-
-		return new GraphComm(createDistGraph(
-				handle, sources, degrees, destinations,
-				null, info.handle, reorder, false));
-	}
-
-	private native long createDistGraph(
-			long comm, int[] sources, int[] degrees, int[] destinations,
-			int[] weights, long info, boolean reorder, boolean weighted)
-					throws MPIException;
-
-
-	/**
-	 * Creates a communicator to which the distributed graph topology
-	 * information is attached.
-	 * <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE_ADJACENT}.
-	 * <p>The number of source/destination nodes is the size of the
-	 * {@code sources}/{@code destinations} argument.
-	 * @param sources       ranks of processes for which the calling process
-	 *                      is a destination
-	 * @param sourceWeights weights of the edges into the calling process
-	 * @param destinations  ranks of processes for which the calling process
-	 *                      is a source
-	 * @param destWeights   weights of the edges out of the calling process
-	 * @param info          hints on optimization and interpretation of weights
-	 * @param reorder       the process may be reordered (true) or not (false)
-	 * @return communicator with distributed graph topology
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final GraphComm createDistGraphAdjacent(
-			int[] sources, int[] sourceWeights,
-			int[] destinations, int[] destWeights, Info info, boolean reorder)
-					throws MPIException
-	{
-		MPI.check();
-
-		return new GraphComm(createDistGraphAdjacent(
-				handle, sources, sourceWeights, destinations,
-				destWeights, info.handle, reorder, true));
-	}
-
-	/**
-	 * Creates a communicator to which the distributed graph topology
-	 * information is attached.
-	 * <p>Java binding of the MPI operation {@code MPI_DIST_GRAPH_CREATE_ADJACENT}
-	 * using {@code MPI_UNWEIGHTED}.
-	 * <p>The number of source/destination nodes is the size of the
-	 * {@code sources}/{@code destinations} argument.
-	 * @param sources      ranks of processes for which the calling process
-	 *                     is a destination
-	 * @param destinations ranks of processes for which the calling process
-	 *                     is a source
-	 * @param info         hints on optimization and interpretation of weights
-	 * @param reorder      the process may be reordered (true) or not (false)
-	 * @return communicator with distributed graph topology
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final GraphComm createDistGraphAdjacent(
-			int[] sources, int[] destinations, Info info, boolean reorder)
-					throws MPIException
-	{
-		MPI.check();
-
-		return new GraphComm(createDistGraphAdjacent(
-				handle, sources, null, destinations, null,
-				info.handle, reorder, false));
-	}
-
-	private native long createDistGraphAdjacent(
-			long comm, int[] sources, int []sourceweights, int[] destinations,
-			int[] distweights, long info, boolean reorder, boolean weighted)
-					throws MPIException;
-
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_SCAN}.
-	 * @param sendbuf send buffer array
-	 * @param recvbuf receive buffer array
-	 * @param count   number of items in input buffer
-	 * @param type    data type of each item in input buffer
-	 * @param op      reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void scan(Object sendbuf, Object recvbuf,
-			int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = type.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = type.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		op.setDatatype(type);
-
-		scan(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
-				count, type.handle, type.baseType, op, op.handle);
-	}
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_SCAN}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param recvbuf receive buffer array
-	 * @param count   number of items in input buffer
-	 * @param type    data type of each item in input buffer
-	 * @param op      reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void scan(Object recvbuf, int count, Datatype type, Op op)
-			throws MPIException
-	{
-		MPI.check();
-		int recvoff = 0;
-		boolean rdb = false;
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = type.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		op.setDatatype(type);
-
-		scan(handle, null, false, 0, recvbuf, rdb, recvoff,
-				count, type.handle, type.baseType, op, op.handle);
-	}
-
-	private native void scan(
-			long comm, Object sendbuf, boolean sdb, int sendoff,
-			Object recvbuf, boolean rdb, int recvoff, int count,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_ISCAN}.
-	 * @param sendbuf send buffer array
-	 * @param recvbuf receive buffer array
-	 * @param count   number of items in input buffer
-	 * @param type    data type of each item in input buffer
-	 * @param op      reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iScan(Buffer sendbuf, Buffer recvbuf,
-			int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iScan(handle, sendbuf, recvbuf, count,
-				type.handle, type.baseType, op, op.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_ISCAN}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   send/receive buffer array
-	 * @param count number of items in buffer
-	 * @param type  data type of each item in buffer
-	 * @param op    reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iScan(Buffer buf, int count, Datatype type, Op op)
-			throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(buf);
-		Request req = new Request(iScan(
-				handle, null, buf, count,
-				type.handle, type.baseType, op, op.handle));
-		req.addSendBufRef(buf);
-		return req;
-	}
-
-	private native long iScan(
-			long comm, Buffer sendbuf, Buffer recvbuf, int count,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_EXSCAN}.
-	 * @param sendbuf send buffer array
-	 * @param recvbuf receive buffer array
-	 * @param count   number of items in input buffer
-	 * @param type    data type of each item in input buffer
-	 * @param op      reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void exScan(Object sendbuf, Object recvbuf,
-			int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-
-		int sendoff = 0,
-				recvoff = 0;
-
-		boolean sdb = false,
-				rdb = false;
-
-		if(sendbuf instanceof Buffer && !(sdb = ((Buffer)sendbuf).isDirect()))
-		{
-			sendoff = type.getOffset(sendbuf);
-			sendbuf = ((Buffer)sendbuf).array();
-		}
-
-		if(recvbuf instanceof Buffer && !(rdb = ((Buffer)recvbuf).isDirect()))
-		{
-			recvoff = type.getOffset(recvbuf);
-			recvbuf = ((Buffer)recvbuf).array();
-		}
-
-		op.setDatatype(type);
-
-		exScan(handle, sendbuf, sdb, sendoff, recvbuf, rdb, recvoff,
-				count, type.handle, type.baseType, op, op.handle);
-	}
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_EXSCAN}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer array
-	 * @param count number of items in input buffer
-	 * @param type  data type of each item in input buffer
-	 * @param op    reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void exScan(Object buf, int count, Datatype type, Op op)
-			throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		op.setDatatype(type);
-
-		exScan(handle, null, false, 0, buf, db, off, count,
-				type.handle, type.baseType, op, op.handle);
-	}
-
-	private native void exScan(
-			long comm, Object sendbuf, boolean sdb, int sendoff,
-			Object recvbuf, boolean rdb, int recvoff, int count,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_IEXSCAN}.
-	 * @param sendbuf send buffer array
-	 * @param recvbuf receive buffer array
-	 * @param count   number of items in input buffer
-	 * @param type    data type of each item in input buffer
-	 * @param op      reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iExScan(Buffer sendbuf, Buffer recvbuf,
-			int count, Datatype type, Op op)
-					throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(sendbuf, recvbuf);
-		Request req = new Request(iExScan(handle, sendbuf, recvbuf, count,
-				type.handle, type.baseType, op, op.handle));
-		req.addSendBufRef(sendbuf);
-		req.addRecvBufRef(recvbuf);
-		return req;
-	}
-
-	/**
-	 * Perform a prefix reduction on data distributed across the group.
-	 * <p>Java binding of the MPI operation {@code MPI_IEXSCAN}
-	 * using {@code MPI_IN_PLACE} instead of the send buffer.
-	 * @param buf   receive buffer array
-	 * @param count number of items in input buffer
-	 * @param type  data type of each item in input buffer
-	 * @param op    reduce operation
-	 * @return communication request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request iExScan(Buffer buf, int count, Datatype type, Op op)
-			throws MPIException
-	{
-		MPI.check();
-		op.setDatatype(type);
-		assertDirectBuffer(buf);
-		Request req = new Request(iExScan(
-				handle, null, buf, count,
-				type.handle, type.baseType, op, op.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long iExScan(
-			long comm, Buffer sendbuf, Buffer recvbuf, int count,
-			long type, int baseType, Op jOp, long hOp) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_OPEN_PORT} using {@code MPI_INFO_NULL}.
-	 * @return port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static String openPort() throws MPIException
-	{
-		MPI.check();
-		return openPort(Info.NULL);
-	}
-
-	/**
-	 * Java binding of {@code MPI_OPEN_PORT}.
-	 * @param info implementation-specific information
-	 * @return port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static String openPort(Info info) throws MPIException
-	{
-		MPI.check();
-		return openPort(info.handle);
-	}
-
-	private native static String openPort(long info) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_CLOSE_PORT}.
-	 * @param name port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void closePort(String name) throws MPIException
-	{
-		MPI.check();
-		closePort_jni(name);
-	}
-
-	private native static void closePort_jni(String name) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_COMM_ACCEPT} using {@code MPI_INFO_NULL}.
-	 * @param port port name
-	 * @param root rank in comm of root node
-	 * @return intercommunicator with client as remote group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intercomm accept(String port, int root) throws MPIException
-	{
-		MPI.check();
-		return new Intercomm(accept(handle, port, Info.NULL, root));
-	}
-
-	/**
-	 * Java binding of {@code MPI_COMM_ACCEPT}.
-	 * @param port port name
-	 * @param info implementation-specific information
-	 * @param root rank in comm of root node
-	 * @return intercommunicator with client as remote group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intercomm accept(String port, Info info, int root)
-			throws MPIException
-	{
-		MPI.check();
-		return new Intercomm(accept(handle, port, info.handle, root));
-	}
-
-	private native long accept(long comm, String port, long info, int root)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_COMM_CONNECT} using {@code MPI_INFO_NULL}.
-	 * @param port port name
-	 * @param root rank in comm of root node
-	 * @return intercommunicator with server as remote group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intercomm connect(String port, int root) throws MPIException
-	{
-		MPI.check();
-		return new Intercomm(connect(handle, port, Info.NULL, root));
-	}
-
-	/**
-	 * Java binding of {@code MPI_COMM_CONNECT}.
-	 * @param port port name
-	 * @param info implementation-specific information
-	 * @param root rank in comm of root node
-	 * @return intercommunicator with server as remote group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intercomm connect(String port, Info info, int root)
-			throws MPIException
-	{
-		MPI.check();
-		return new Intercomm(connect(handle, port, info.handle, root));
-	}
-
-	private native long connect(long comm, String port, long info, int root)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_PUBLISH_NAME} using {@code MPI_INFO_NULL}.
-	 * @param service service name
-	 * @param port    port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void publishName(String service, String port)
-			throws MPIException
-	{
-		MPI.check();
-		publishName(service, Info.NULL, port);
-	}
-
-	/**
-	 * Java binding of {@code MPI_PUBLISH_NAME}.
-	 * @param service service name
-	 * @param info    implementation-specific information
-	 * @param port    port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void publishName(String service, Info info, String port)
-			throws MPIException
-	{
-		MPI.check();
-		publishName(service, info.handle, port);
-	}
-
-	private native static void publishName(String service, long info, String port)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_UNPUBLISH_NAME} using {@code MPI_INFO_NULL}.
-	 * @param service service name
-	 * @param port    port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void unpublishName(String service, String port)
-			throws MPIException
-	{
-		MPI.check();
-		unpublishName(service, Info.NULL, port);
-	}
-
-	/**
-	 * Java binding of {@code MPI_UNPUBLISH_NAME}.
-	 * @param service service name
-	 * @param info    implementation-specific information
-	 * @param port    port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void unpublishName(String service, Info info, String port)
-			throws MPIException
-	{
-		MPI.check();
-		unpublishName(service, info.handle, port);
-	}
-
-	private native static void unpublishName(String service, long info, String port)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_LOOKUP_NAME} using {@code MPI_INFO_NULL}.
-	 * @param service service name
-	 * @return port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static String lookupName(String service) throws MPIException
-	{
-		MPI.check();
-		return lookupName(service, Info.NULL);
-	}
-
-	/**
-	 * Java binding of {@code MPI_LOOKUP_NAME}.
-	 * @param service service name
-	 * @param info    implementation-specific information
-	 * @return port name
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static String lookupName(String service, Info info) throws MPIException
-	{
-		MPI.check();
-		return lookupName(service, info.handle);
-	}
-
-	private native static String lookupName(String service, long info)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_COMM_SPAWN}.
-	 * This intracommunicator will contain the group of spawned processes.
-	 * @param command  name of program to be spawned
-	 * @param argv     arguments to command; if this parameter is null,
-	 *                 {@code MPI_ARGV_NULL} will be used.
-	 * @param maxprocs maximum number of processes to start
-	 * @param info     info object telling the runtime where
-	 *                 and how to start the processes
-	 * @param root     rank of process in which previous arguments are examined
-	 * @param errcodes one code per process; if this parameter is null,
-	 *                 {@code MPI_ERRCODES_IGNORE} will be used.
-	 * @return intercommunicator between original group and the newly spawned group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intercomm spawn(String command, String[] argv, int maxprocs,
-			Info info, int root, int[] errcodes)
-					throws MPIException
-	{
-		MPI.check();
-
-		return new Intercomm(spawn(handle, command, argv, maxprocs,
-				info.handle, root, errcodes));
-	}
-
-	private native long spawn(long comm, String command, String[] argv,
-			int maxprocs, long info, int root, int[] errcodes)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_COMM_SPAWN_MULTIPLE}.
-	 * This intracommunicator will contain the group of spawned processes.
-	 * @param commands programs to be executed
-	 * @param argv     arguments for commands; if this parameter is null,
-	 *                 {@code MPI_ARGVS_NULL} will be used.
-	 * @param maxprocs maximum number of processes to start for each command
-	 * @param info     info objects telling the runtime where
-	 *                 and how to start the processes
-	 * @param root     rank of process in which previous arguments are examined
-	 * @param errcodes one code per process; if this parameter is null,
-	 *                 {@code MPI_ERRCODES_IGNORE} will be used.
-	 * @return intercommunicator between original group and the newly spawned group
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Intercomm spawnMultiple(
-			String[] commands, String[][] argv, int[] maxprocs,
-			Info[] info, int root, int[] errcodes)
-					throws MPIException
-	{
-		MPI.check();
-
-		long hInfo[] = new long[info.length];
-
-		for(int i = 0; i < info.length; i++)
-			hInfo[i] = info[i].handle;
-
-		return new Intercomm(spawnMultiple(handle, commands, argv, maxprocs,
-				hInfo, root, errcodes));
-	}
-
-	private native long spawnMultiple(
-			long comm, String[] commands, String[][] argv, int[] maxprocs,
-			long[] info, int root, int[] errcodes) throws MPIException;
-
-} // Intracomm
diff --git a/ompi/mpi/java/java/LongInt.java b/ompi/mpi/java/java/LongInt.java
deleted file mode 100644
index 2d9a9143f31..00000000000
--- a/ompi/mpi/java/java/LongInt.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * Struct class for {@link MPI#LONG_INT} datatype.
- */
-public final class LongInt extends Struct
-{
-	private final int lSize, iOff, iSize;
-
-	/**
-	 * The struct object will be created only in MPI class.
-	 * @param longSize	size of long
-	 * @param intOff	int offset
-	 * @param intSize	int size
-	 * @see MPI#longInt
-	 */
-	protected LongInt(int longSize, int intOff, int intSize)
-	{
-		lSize = longSize;
-		iSize = intSize;
-		int lOff;
-
-		switch(lSize)
-		{
-		case 4: lOff = addInt();  break;
-		case 8: lOff = addLong(); break;
-		default: throw new AssertionError("Unsupported long size: "+ lSize);
-		}
-
-		assert lOff == 0;
-		setOffset(intOff);
-
-		switch(iSize)
-		{
-		case 4: iOff = addInt();  break;
-		case 8: iOff = addLong(); break;
-		default: throw new AssertionError("Unsupported int size: "+ iSize);
-		}
-
-		assert(intOff == iOff);
-	}
-
-	/**
-	 * Creates a Data object.
-	 * @return new Data object.
-	 */
-	@Override protected LongInt.Data newData()
-	{
-		return new LongInt.Data();
-	}
-
-	/**
-	 * Class for reading/writing data in a struct stored in a byte buffer.
-	 */
-	public final class Data extends Struct.Data
-	{
-		/**
-		 * Gets the long value.
-		 * @return long value
-		 */
-		public long getValue()
-		{
-			switch(lSize)
-			{
-			case 8: return getLong(0);
-			case 4: return getInt(0);
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Gets the int value.
-		 * @return int value
-		 */
-		public int getIndex()
-		{
-			switch(iSize)
-			{
-			case 4: return getInt(iOff);
-			case 8: return (int)getLong(iOff);
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Puts the long value.
-		 * @param v long value
-		 */
-		public void putValue(long v)
-		{
-			switch(lSize)
-			{
-			case 8: putLong(0, v);     break;
-			case 4: putInt(0, (int)v); break;
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Puts the int value.
-		 * @param v int value
-		 */
-		public void putIndex(int v)
-		{
-			switch(iSize)
-			{
-			case 4: putInt(iOff, v);  break;
-			case 8: putLong(iOff, v); break;
-			default: throw new AssertionError();
-			}
-		}
-	} // Data
-
-} // LongInt
diff --git a/ompi/mpi/java/java/MPI.java b/ompi/mpi/java/java/MPI.java
deleted file mode 100644
index e8887faede0..00000000000
--- a/ompi/mpi/java/java/MPI.java
+++ /dev/null
@@ -1,1014 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2020 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : MPI.java
- * Author       : Sang Lim, Sung-Hoon Ko, Xinying Li, Bryan Carpenter
- *                (contributions from MAEDA Atusi)
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.18 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-package mpi;
-
-import java.io.*;
-import java.nio.*;
-
-/**
- * MPI environment.
- */
-public final class MPI
-{
-	private static boolean initialized, finalized;
-	private static byte[] buffer = null; // Buffer allocation
-	private static final int MAX_PROCESSOR_NAME = 256;
-	private static final ByteOrder nativeOrder = ByteOrder.nativeOrder();
-
-	public static final Intracomm COMM_WORLD, COMM_SELF;
-
-	public static final int THREAD_SINGLE, THREAD_FUNNELED, THREAD_SERIALIZED,
-	THREAD_MULTIPLE;
-
-	public static final int GRAPH, DIST_GRAPH, CART;
-	public static final int ANY_SOURCE, ANY_TAG;
-
-	public static final Op MAX, MIN, SUM, PROD, LAND, BAND,
-	LOR, BOR, LXOR, BXOR, REPLACE, NO_OP;
-
-	/**
-	 * Global minimum operator.
-	 * <p>{@code MINLOC} and {@link #MAXLOC} can be used with each of the following
-	 * datatypes: {@link #INT2}, {@link #SHORT_INT}, {@link #LONG_INT},
-	 * {@link #FLOAT_INT} and {@link #DOUBLE_INT}.
-	 */
-	public static final Op MINLOC;
-
-	/** Global maximum operator. See {@link #MINLOC}.*/
-	public static final Op MAXLOC;
-
-	public static final Datatype DATATYPE_NULL;
-
-	public static final Datatype BYTE, CHAR, SHORT, BOOLEAN,
-	INT, LONG, FLOAT, DOUBLE, PACKED,
-	FLOAT_COMPLEX, DOUBLE_COMPLEX;
-
-	/** Struct which must be used with {@link #int2}. */
-	public static final Datatype INT2;
-	/** Struct which must be used with {@link #shortInt}. */
-	public static final Datatype SHORT_INT;
-	/** Struct which must be used with {@link #longInt}. */
-	public static final Datatype LONG_INT;
-	/** Struct which must be used with {@link #floatInt}. */
-	public static final Datatype FLOAT_INT;
-	/** Struct which must be used with {@link #doubleInt}. */
-	public static final Datatype DOUBLE_INT;
-
-	/** Struct object for {@link #INT2} datatype. */
-	public static final Int2 int2;
-	/** Struct object for {@link #SHORT_INT} datatype. */
-	public static final ShortInt shortInt;
-	/** Struct object for {@link #LONG_INT} datatype. */
-	public static final LongInt longInt;
-	/** Struct object for {@link #FLOAT_INT} datatype. */
-	public static final FloatInt floatInt;
-	/** Struct object for {@link #DOUBLE_INT} datatype. */
-	public static final DoubleInt doubleInt;
-
-	public static final Request REQUEST_NULL;
-	public static final Group GROUP_EMPTY;
-	public static final Info INFO_ENV, INFO_NULL;
-
-	public static final int PROC_NULL;
-	public static final int UNDEFINED;
-	public static final int IDENT, CONGRUENT, SIMILAR, UNEQUAL;
-	public static final int TAG_UB, HOST, IO, WTIME_IS_GLOBAL;
-
-	public static final int APPNUM, LASTUSEDCODE, UNIVERSE_SIZE, WIN_BASE,
-	WIN_SIZE, WIN_DISP_UNIT;
-
-	public static final int VERSION, SUBVERSION;
-	public static final int ROOT, KEYVAL_INVALID, BSEND_OVERHEAD;
-	public static final int MAX_OBJECT_NAME, MAX_PORT_NAME, MAX_DATAREP_STRING;
-	public static final int MAX_INFO_KEY, MAX_INFO_VAL;
-	public static final int ORDER_C, ORDER_FORTRAN;
-	public static final int DISTRIBUTE_BLOCK, DISTRIBUTE_CYCLIC, DISTRIBUTE_NONE,
-	DISTRIBUTE_DFLT_DARG;
-
-	public static final int MODE_CREATE, MODE_RDONLY, MODE_WRONLY, MODE_RDWR,
-	MODE_DELETE_ON_CLOSE, MODE_UNIQUE_OPEN, MODE_EXCL,
-	MODE_APPEND, MODE_SEQUENTIAL;
-	public static final int DISPLACEMENT_CURRENT;
-	public static final int SEEK_SET, SEEK_CUR, SEEK_END;
-
-	public static final int MODE_NOCHECK, MODE_NOPRECEDE, MODE_NOPUT,
-	MODE_NOSTORE, MODE_NOSUCCEED;
-	public static final int LOCK_EXCLUSIVE, LOCK_SHARED;
-
-	public static final Errhandler ERRORS_ARE_FATAL, ERRORS_ABORT, ERRORS_RETURN;
-
-	// Error classes and codes
-	public static final int SUCCESS;
-	public static final int ERR_BUFFER;
-	public static final int ERR_COUNT;
-	public static final int ERR_TYPE;
-	public static final int ERR_TAG;
-	public static final int ERR_COMM;
-	public static final int ERR_RANK;
-	public static final int ERR_REQUEST;
-	public static final int ERR_ROOT;
-	public static final int ERR_GROUP;
-	public static final int ERR_OP;
-	public static final int ERR_TOPOLOGY;
-	public static final int ERR_DIMS;
-	public static final int ERR_ARG;
-	public static final int ERR_UNKNOWN;
-	public static final int ERR_TRUNCATE;
-	public static final int ERR_OTHER;
-	public static final int ERR_INTERN;
-	public static final int ERR_IN_STATUS;
-	public static final int ERR_PENDING;
-	public static final int ERR_ACCESS;
-	public static final int ERR_AMODE;
-	public static final int ERR_ASSERT;
-	public static final int ERR_BAD_FILE;
-	public static final int ERR_BASE;
-	public static final int ERR_CONVERSION;
-	public static final int ERR_DISP;
-	public static final int ERR_DUP_DATAREP;
-	public static final int ERR_FILE_EXISTS;
-	public static final int ERR_FILE_IN_USE;
-	public static final int ERR_FILE;
-	public static final int ERR_INFO_KEY;
-	public static final int ERR_INFO_NOKEY;
-	public static final int ERR_INFO_VALUE;
-	public static final int ERR_INFO;
-	public static final int ERR_IO;
-	public static final int ERR_KEYVAL;
-	public static final int ERR_LOCKTYPE;
-	public static final int ERR_NAME;
-	public static final int ERR_NO_MEM;
-	public static final int ERR_NOT_SAME;
-	public static final int ERR_NO_SPACE;
-	public static final int ERR_NO_SUCH_FILE;
-	public static final int ERR_PORT;
-	public static final int ERR_PROC_ABORTED;
-	public static final int ERR_QUOTA;
-	public static final int ERR_READ_ONLY;
-	public static final int ERR_RMA_CONFLICT;
-	public static final int ERR_RMA_SYNC;
-	public static final int ERR_SERVICE;
-	public static final int ERR_SIZE;
-	public static final int ERR_SPAWN;
-	public static final int ERR_UNSUPPORTED_DATAREP;
-	public static final int ERR_UNSUPPORTED_OPERATION;
-	public static final int ERR_WIN;
-	public static final int ERR_LASTCODE;
-	public static final int ERR_SYSRESOURCE;
-
-	static
-	{
-		try
-		{
-			System.loadLibrary("mpi_java") ;
-		}
-		catch (UnsatisfiedLinkError e)
-		{
-			System.err.println("mpi java lib failed to load: " + e  + "\n") ;
-			System.exit(1) ;
-		}
-
-		DATATYPE_NULL = new Datatype();
-
-		BYTE    = new Datatype();
-		CHAR    = new Datatype();
-		SHORT   = new Datatype();
-		BOOLEAN = new Datatype();
-		INT     = new Datatype();
-		LONG    = new Datatype();
-		FLOAT   = new Datatype();
-		DOUBLE  = new Datatype();
-		PACKED  = new Datatype();
-		INT2    = new Datatype();
-
-		SHORT_INT  = new Datatype();
-		LONG_INT   = new Datatype();
-		FLOAT_INT  = new Datatype();
-		DOUBLE_INT = new Datatype();
-		FLOAT_COMPLEX  = new Datatype();
-		DOUBLE_COMPLEX = new Datatype();
-
-		int2      = newInt2();
-		shortInt  = newShortInt();
-		longInt   = newLongInt();
-		floatInt  = newFloatInt();
-		doubleInt = newDoubleInt();
-
-		MAX    = new Op(1);
-		MIN    = new Op(2);
-		SUM    = new Op(3);
-		PROD   = new Op(4);
-		LAND   = new Op(5);
-		BAND   = new Op(6);
-		LOR    = new Op(7);
-		BOR    = new Op(8);
-		LXOR   = new Op(9);
-		BXOR   = new Op(10);
-		MINLOC = new Op(11);
-		MAXLOC = new Op(12);
-		REPLACE = new Op(13);
-		NO_OP = new Op(14);
-
-		GROUP_EMPTY  = new Group(Group.getEmpty());
-		REQUEST_NULL = new Request(Request.getNull());
-		INFO_ENV     = Info.newEnv();
-		INFO_NULL    = new Info(Info.NULL);
-
-		Constant c = new Constant();
-
-		THREAD_SINGLE     = c.THREAD_SINGLE;
-		THREAD_FUNNELED   = c.THREAD_FUNNELED;
-		THREAD_SERIALIZED = c.THREAD_SERIALIZED;
-		THREAD_MULTIPLE   = c.THREAD_MULTIPLE;
-
-		GRAPH      = c.GRAPH;
-		DIST_GRAPH = c.DIST_GRAPH;
-		CART       = c.CART;
-
-		ANY_SOURCE = c.ANY_SOURCE;
-		ANY_TAG    = c.ANY_TAG;
-		PROC_NULL  = c.PROC_NULL;
-
-		UNDEFINED = c.UNDEFINED;
-
-		IDENT     = c.IDENT;
-		CONGRUENT = c.CONGRUENT;
-		SIMILAR   = c.SIMILAR;
-		UNEQUAL   = c.UNEQUAL;
-
-		TAG_UB          = c.TAG_UB;
-		HOST            = c.HOST;
-		IO              = c.IO;
-		WTIME_IS_GLOBAL = c.WTIME_IS_GLOBAL;
-
-		APPNUM        = c.APPNUM;
-		LASTUSEDCODE  = c.LASTUSEDCODE;
-		UNIVERSE_SIZE = c.UNIVERSE_SIZE;
-		WIN_BASE      = c.WIN_BASE;
-		WIN_SIZE      = c.WIN_SIZE;
-		WIN_DISP_UNIT = c.WIN_DISP_UNIT;
-
-		VERSION    = c.VERSION;
-		SUBVERSION = c.SUBVERSION;
-
-		ROOT           = c.ROOT;
-		KEYVAL_INVALID = c.KEYVAL_INVALID;
-		BSEND_OVERHEAD = c.BSEND_OVERHEAD;
-
-		MAX_OBJECT_NAME    = c.MAX_OBJECT_NAME;
-		MAX_PORT_NAME      = c.MAX_PORT_NAME;
-		MAX_DATAREP_STRING = c.MAX_DATAREP_STRING;
-
-		MAX_INFO_KEY = c.MAX_INFO_KEY;
-		MAX_INFO_VAL = c.MAX_INFO_VAL;
-
-		ORDER_C       = c.ORDER_C;
-		ORDER_FORTRAN = c.ORDER_FORTRAN;
-
-		DISTRIBUTE_BLOCK     = c.DISTRIBUTE_BLOCK;
-		DISTRIBUTE_CYCLIC    = c.DISTRIBUTE_CYCLIC;
-		DISTRIBUTE_NONE      = c.DISTRIBUTE_NONE;
-		DISTRIBUTE_DFLT_DARG = c.DISTRIBUTE_DFLT_DARG;
-
-		MODE_CREATE          = c.MODE_CREATE;
-		MODE_RDONLY          = c.MODE_RDONLY;
-		MODE_WRONLY          = c.MODE_WRONLY;
-		MODE_RDWR            = c.MODE_RDWR;
-		MODE_DELETE_ON_CLOSE = c.MODE_DELETE_ON_CLOSE;
-		MODE_UNIQUE_OPEN     = c.MODE_UNIQUE_OPEN;
-		MODE_EXCL            = c.MODE_EXCL;
-		MODE_APPEND          = c.MODE_APPEND;
-		MODE_SEQUENTIAL      = c.MODE_SEQUENTIAL;
-
-		DISPLACEMENT_CURRENT = c.DISPLACEMENT_CURRENT;
-
-		SEEK_SET = c.SEEK_SET;
-		SEEK_CUR = c.SEEK_CUR;
-		SEEK_END = c.SEEK_END;
-
-		MODE_NOCHECK   = c.MODE_NOCHECK;
-		MODE_NOPRECEDE = c.MODE_NOPRECEDE;
-		MODE_NOPUT     = c.MODE_NOPUT;
-		MODE_NOSTORE   = c.MODE_NOSTORE;
-		MODE_NOSUCCEED = c.MODE_NOSUCCEED;
-		LOCK_EXCLUSIVE = c.LOCK_EXCLUSIVE;
-		LOCK_SHARED    = c.LOCK_SHARED;
-
-		ERRORS_ARE_FATAL = new Errhandler(Errhandler.getFatal());
-		ERRORS_ABORT     = new Errhandler(Errhandler.getAbort());
-		ERRORS_RETURN    = new Errhandler(Errhandler.getReturn());
-
-		COMM_WORLD = new Intracomm();
-		COMM_SELF  = new Intracomm();
-
-		// Error classes and codes
-		SUCCESS          = c.SUCCESS;
-		ERR_BUFFER       = c.ERR_BUFFER;
-		ERR_COUNT        = c.ERR_COUNT;
-		ERR_TYPE         = c.ERR_TYPE;
-		ERR_TAG          = c.ERR_TAG;
-		ERR_COMM         = c.ERR_COMM;
-		ERR_RANK         = c.ERR_RANK;
-		ERR_REQUEST      = c.ERR_REQUEST;
-		ERR_ROOT         = c.ERR_ROOT;
-		ERR_GROUP        = c.ERR_GROUP;
-		ERR_OP           = c.ERR_OP;
-		ERR_TOPOLOGY     = c.ERR_TOPOLOGY;
-		ERR_DIMS         = c.ERR_DIMS;
-		ERR_ARG          = c.ERR_ARG;
-		ERR_UNKNOWN      = c.ERR_UNKNOWN;
-		ERR_TRUNCATE     = c.ERR_TRUNCATE;
-		ERR_OTHER        = c.ERR_OTHER;
-		ERR_INTERN       = c.ERR_INTERN;
-		ERR_IN_STATUS    = c.ERR_IN_STATUS;
-		ERR_PENDING      = c.ERR_PENDING;
-		ERR_ACCESS       = c.ERR_ACCESS;
-		ERR_AMODE        = c.ERR_AMODE;
-		ERR_ASSERT       = c.ERR_ASSERT;
-		ERR_BAD_FILE     = c.ERR_BAD_FILE;
-		ERR_BASE         = c.ERR_BASE;
-		ERR_CONVERSION   = c.ERR_CONVERSION;
-		ERR_DISP         = c.ERR_DISP;
-		ERR_DUP_DATAREP  = c.ERR_DUP_DATAREP;
-		ERR_FILE_EXISTS  = c.ERR_FILE_EXISTS;
-		ERR_FILE_IN_USE  = c.ERR_FILE_IN_USE;
-		ERR_FILE         = c.ERR_FILE;
-		ERR_INFO_KEY     = c.ERR_INFO_KEY;
-		ERR_INFO_NOKEY   = c.ERR_INFO_NOKEY;
-		ERR_INFO_VALUE   = c.ERR_INFO_VALUE;
-		ERR_INFO         = c.ERR_INFO;
-		ERR_IO           = c.ERR_IO;
-		ERR_KEYVAL       = c.ERR_KEYVAL;
-		ERR_LOCKTYPE     = c.ERR_LOCKTYPE;
-		ERR_NAME         = c.ERR_NAME;
-		ERR_NO_MEM       = c.ERR_NO_MEM;
-		ERR_NOT_SAME     = c.ERR_NOT_SAME;
-		ERR_NO_SPACE     = c.ERR_NO_SPACE;
-		ERR_NO_SUCH_FILE = c.ERR_NO_SUCH_FILE;
-		ERR_PORT         = c.ERR_PORT;
-		ERR_PROC_ABORTED = c.ERR_PROC_ABORTED;
-		ERR_QUOTA        = c.ERR_QUOTA;
-		ERR_READ_ONLY    = c.ERR_READ_ONLY;
-		ERR_RMA_CONFLICT = c.ERR_RMA_CONFLICT;
-		ERR_RMA_SYNC     = c.ERR_RMA_SYNC;
-		ERR_SERVICE      = c.ERR_SERVICE;
-		ERR_SIZE         = c.ERR_SIZE;
-		ERR_SPAWN        = c.ERR_SPAWN;
-		ERR_UNSUPPORTED_DATAREP   = c.ERR_UNSUPPORTED_DATAREP;
-		ERR_UNSUPPORTED_OPERATION = c.ERR_UNSUPPORTED_OPERATION;
-		ERR_WIN          = c.ERR_WIN;
-		ERR_LASTCODE     = c.ERR_LASTCODE;
-		ERR_SYSRESOURCE  = c.ERR_SYSRESOURCE;
-
-		initVersion();
-	}
-
-	private static native Int2      newInt2();
-	private static native ShortInt  newShortInt();
-	private static native LongInt   newLongInt();
-	private static native FloatInt  newFloatInt();
-	private static native DoubleInt newDoubleInt();
-	private static native void initVersion();
-
-	private static void initCommon() throws MPIException
-	{
-		initialized = true;
-
-		DATATYPE_NULL.setBasic(Datatype.NULL);
-
-		BYTE.setBasic(Datatype.BYTE);
-		CHAR.setBasic(Datatype.CHAR);
-		SHORT.setBasic(Datatype.SHORT);
-		BOOLEAN.setBasic(Datatype.BOOLEAN);
-		INT.setBasic(Datatype.INT);
-		LONG.setBasic(Datatype.LONG);
-		FLOAT.setBasic(Datatype.FLOAT);
-		DOUBLE.setBasic(Datatype.DOUBLE);
-		PACKED.setBasic(Datatype.PACKED);
-
-		INT2.setBasic(Datatype.INT2, MPI.BYTE);
-		SHORT_INT.setBasic(Datatype.SHORT_INT, MPI.BYTE);
-		LONG_INT.setBasic(Datatype.LONG_INT, MPI.BYTE);
-		FLOAT_INT.setBasic(Datatype.FLOAT_INT, MPI.BYTE);
-		DOUBLE_INT.setBasic(Datatype.DOUBLE_INT, MPI.BYTE);
-		FLOAT_COMPLEX.setBasic(Datatype.FLOAT_COMPLEX, MPI.FLOAT);
-		DOUBLE_COMPLEX.setBasic(Datatype.DOUBLE_COMPLEX, MPI.DOUBLE);
-
-		COMM_WORLD.setType(Intracomm.WORLD);
-		COMM_SELF.setType(Intracomm.SELF);
-	}
-
-	/**
-	 * Initialize MPI.
-	 * <p>Java binding of the MPI operation {@code MPI_INIT}.
-	 * @param args arguments to the {@code main} method.
-	 * @return arguments
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static String[] Init(String[] args) throws MPIException
-	{
-		if(initialized)
-			throw new MPIException("MPI is already initialized.");
-
-		String[] newArgs = Init_jni(args);
-		initCommon();
-		return newArgs;
-	}
-
-	private static native String [] Init_jni(String[] args);
-
-	/**
-	 * Initialize MPI with threads.
-	 * <p>Java binding of the MPI operation {@code MPI_INIT_THREAD}.
-	 * @param args     arguments to the {@code main} method.
-	 * @param required desired level of thread support
-	 * @return provided level of thread support
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int InitThread(String[] args, int required) throws MPIException
-	{
-		if(initialized)
-			throw new MPIException("MPI is already initialized.");
-
-		int provided = InitThread_jni(args, required);
-		initCommon();
-		return provided;
-	}
-
-	private static native int InitThread_jni(String[] args, int required)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_QUERY_THREAD}.
-	 * @return provided level of thread support
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int queryThread() throws MPIException
-	{
-		MPI.check();
-		return queryThread_jni();
-	}
-
-	private static native int queryThread_jni() throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_IS_THREAD_MAIN}.
-	 * @return true if it is the main thread
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static boolean isThreadMain() throws MPIException
-	{
-		MPI.check();
-		return isThreadMain_jni();
-	}
-
-	private static native boolean isThreadMain_jni() throws MPIException;
-
-	/**
-	 * Finalize MPI.
-	 * <p>Java binding of the MPI operation {@code MPI_FINALIZE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void Finalize() throws MPIException
-	{
-		check();
-		Finalize_jni();
-		finalized = true;
-	}
-
-	private static native void Finalize_jni() throws MPIException;
-
-	/**
-	 * Returns an elapsed time on the calling processor.
-	 * <p>Java binding of the MPI operation {@code MPI_WTIME}.
-	 * @return time in seconds since an arbitrary time in the past.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static double wtime() throws MPIException
-	{
-		check();
-		return wtime_jni();
-	}
-
-	private static native double wtime_jni();
-
-	/**
-	 * Returns resolution of timer.
-	 * <p>Java binding of the MPI operation {@code MPI_WTICK}.
-	 * @return resolution of {@code wtime} in seconds.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static double wtick() throws MPIException
-	{
-		check();
-		return wtick_jni();
-	}
-
-	private static native double wtick_jni();
-
-	/**
-	 * Returns a version object representing the version of MPI being used.
-	 * <p>Java binding of the MPI operation {@code MPI_GET_VERSION}.
-	 * @return A version object representing the version and subversion of MPI being used.
-	 */
-	public static Version getVersion() {
-		return getVersionJNI();
-	}
-
-	private static native Version getVersionJNI();
-
-	/**
-	 * Returns the version of the MPI Library
-	 * <p>Java binding of the MPI operation {@code MPI_GET_LIBRARY_VERSION}.
-	 * @return A string representation of the MPI Library
-	 */
-	public static String getLibVersion() {
-		return getLibVersionJNI();
-	}
-
-	private static native String getLibVersionJNI();
-
-	/**
-	 * Returns the name of the processor on which it is called.
-	 * <p>Java binding of the MPI operation {@code MPI_GET_PROCESSOR_NAME}.
-	 * @return A unique specifier for the actual node.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	static public String getProcessorName() throws MPIException
-	{
-		check();
-		byte[] buf = new byte[MAX_PROCESSOR_NAME];
-		int lengh = getProcessorName(buf);
-		return new String(buf,0,lengh);
-	}
-
-	static private native int getProcessorName(byte[] buf);
-
-	/**
-	 * Test if MPI has been initialized.
-	 * <p>Java binding of the MPI operation {@code MPI_INITIALIZED}.
-	 * @return {@code true} if {@code Init} has been called,
-	 *         {@code false} otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	static public native boolean isInitialized() throws MPIException;
-
-	/**
-	 * Test if MPI has been finalized.
-	 * <p>Java binding of the MPI operation {@code MPI_FINALIZED}.
-	 * @return {@code true} if {@code Finalize} has been called,
-	 *         {@code false} otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	static public native boolean isFinalized() throws MPIException;
-
-	/**
-	 * Attaches a user-provided buffer for sending.
-	 * <p>Java binding of the MPI operation {@code MPI_BUFFER_ATTACH}.
-	 * @param buffer initial buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	static public void attachBuffer(byte[] buffer) throws MPIException
-	{
-		check();
-		MPI.buffer = buffer;
-		attachBuffer_jni(buffer);
-	}
-
-	static private native void attachBuffer_jni(byte[] buffer);
-
-	/**
-	 * Removes an existing buffer (for use in sending).
-	 * <p>Java binding of the MPI operation {@code MPI_BUFFER_DETACH}.
-	 * @return initial buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	static public byte[] detachBuffer() throws MPIException
-	{
-		check();
-		detachBuffer_jni(buffer);
-		byte[] result = MPI.buffer;
-		MPI.buffer = null;
-		return result;
-	}
-
-	static private native void detachBuffer_jni(byte[] buffer);
-
-	/**
-	 * Controls profiling.
-	 * <p>This method is not implemented.
-	 * <p>Java binding of the MPI operation {@code MPI_PCONTROL}.
-	 * @param level Profiling level.
-	 * @param obj   Profiling information.
-	 */
-	public static void pControl(int level, Object obj)
-	{
-		// Nothing to do here.
-	}
-
-	/**
-	 * Check if MPI has been initialized and hasn't been finalized.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	protected static void check() throws MPIException
-	{
-		if(!initialized)
-			throw new MPIException("MPI is not initialized.");
-
-		if(finalized)
-			throw new MPIException("MPI is finalized.");
-	}
-
-	protected static byte[] attrSet(Object value) throws MPIException
-	{
-		try
-		{
-			ByteArrayOutputStream baos = new ByteArrayOutputStream();
-			ObjectOutputStream os = new ObjectOutputStream(baos);
-			os.writeObject(value);
-			os.close();
-			return baos.toByteArray();
-		}
-		catch(IOException ex)
-		{
-			MPIException mpiex = new MPIException(ex);
-			mpiex.setStackTrace(ex.getStackTrace());
-			throw mpiex;
-		}
-	}
-
-	protected static Object attrGet(byte[] value) throws MPIException
-	{
-		if(value == null)
-			return null;
-
-		try
-		{
-			ByteArrayInputStream bais = new ByteArrayInputStream(value);
-			ObjectInputStream is = new ObjectInputStream(bais);
-			Object obj = is.readObject();
-			is.close();
-			return obj;
-		}
-		catch(ClassNotFoundException ex)
-		{
-			throw new MPIException(ex);
-		}
-		catch(IOException ex)
-		{
-			throw new MPIException(ex);
-		}
-	}
-
-	/**
-	 * Allocates a new direct byte buffer.
-	 * @param capacity The new buffer's capacity, in bytes
-	 * @return The new byte buffer
-	 */
-	public static ByteBuffer newByteBuffer(int capacity)
-	{
-		ByteBuffer buf = ByteBuffer.allocateDirect(capacity);
-		buf.order(nativeOrder);
-		return buf;
-	}
-
-	/**
-	 * Allocates a new direct char buffer.
-	 * @param capacity The new buffer's capacity, in chars
-	 * @return The new char buffer
-	 */
-	public static CharBuffer newCharBuffer(int capacity)
-	{
-		assert capacity <= Integer.MAX_VALUE / 2;
-		ByteBuffer buf = ByteBuffer.allocateDirect(capacity * 2);
-		buf.order(nativeOrder);
-		return buf.asCharBuffer();
-	}
-
-	/**
-	 * Allocates a new direct short buffer.
-	 * @param capacity The new buffer's capacity, in shorts
-	 * @return The new short buffer
-	 */
-	public static ShortBuffer newShortBuffer(int capacity)
-	{
-		assert capacity <= Integer.MAX_VALUE / 2;
-		ByteBuffer buf = ByteBuffer.allocateDirect(capacity * 2);
-		buf.order(nativeOrder);
-		return buf.asShortBuffer();
-	}
-
-	/**
-	 * Allocates a new direct int buffer.
-	 * @param capacity The new buffer's capacity, in ints
-	 * @return The new int buffer
-	 */
-	public static IntBuffer newIntBuffer(int capacity)
-	{
-		assert capacity <= Integer.MAX_VALUE / 4;
-		ByteBuffer buf = ByteBuffer.allocateDirect(capacity * 4);
-		buf.order(nativeOrder);
-		return buf.asIntBuffer();
-	}
-
-	/**
-	 * Allocates a new direct long buffer.
-	 * @param capacity The new buffer's capacity, in longs
-	 * @return The new long buffer
-	 */
-	public static LongBuffer newLongBuffer(int capacity)
-	{
-		assert capacity <= Integer.MAX_VALUE / 8;
-		ByteBuffer buf = ByteBuffer.allocateDirect(capacity * 8);
-		buf.order(nativeOrder);
-		return buf.asLongBuffer();
-	}
-
-	/**
-	 * Allocates a new direct float buffer.
-	 * @param capacity The new buffer's capacity, in floats
-	 * @return The new float buffer
-	 */
-	public static FloatBuffer newFloatBuffer(int capacity)
-	{
-		assert capacity <= Integer.MAX_VALUE / 4;
-		ByteBuffer buf = ByteBuffer.allocateDirect(capacity * 4);
-		buf.order(nativeOrder);
-		return buf.asFloatBuffer();
-	}
-
-	/**
-	 * Allocates a new direct double buffer.
-	 * @param capacity The new buffer's capacity, in doubles
-	 * @return The new double buffer
-	 */
-	public static DoubleBuffer newDoubleBuffer(int capacity)
-	{
-		assert capacity <= Integer.MAX_VALUE / 8;
-		ByteBuffer buf = ByteBuffer.allocateDirect(capacity * 8);
-		buf.order(nativeOrder);
-		return buf.asDoubleBuffer();
-	}
-
-	/**
-	 * Asserts that a buffer is direct.
-	 * @param buf buffer
-	 */
-	protected static void assertDirectBuffer(Buffer buf)
-	{
-		if(!buf.isDirect())
-			throw new IllegalArgumentException("The buffer must be direct.");
-	}
-
-	/**
-	 * Asserts that buffers are direct.
-	 * @param sendbuf	The send buffer
-	 * @param recvbuf	The receive buffer
-	 */
-	protected static void assertDirectBuffer(Buffer sendbuf, Buffer recvbuf)
-	{
-		if(!sendbuf.isDirect())
-			throw new IllegalArgumentException("The send buffer must be direct.");
-
-		if(!recvbuf.isDirect())
-			throw new IllegalArgumentException("The recv. buffer must be direct.");
-	}
-
-	/**
-	 * Checks if an object is a direct buffer.
-	 * @param obj object
-	 * @return true if the object is a direct buffer
-	 */
-	protected static boolean isDirectBuffer(Object obj)
-	{
-		return obj instanceof Buffer && ((Buffer)obj).isDirect();
-	}
-
-	/**
-	 * Checks if an object is a heap buffer.
-	 * @param obj object
-	 * @return true if the object is a heap buffer
-	 */
-	protected static boolean isHeapBuffer(Object obj)
-	{
-		return obj instanceof Buffer && !((Buffer)obj).isDirect();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static ByteBuffer slice(ByteBuffer buf, int offset)
-	{
-		return ((ByteBuffer)buf.clear().position(offset))
-				.slice().order(nativeOrder);
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static CharBuffer slice(CharBuffer buf, int offset)
-	{
-		return ((CharBuffer)buf.clear().position(offset)).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static ShortBuffer slice(ShortBuffer buf, int offset)
-	{
-		return ((ShortBuffer)buf.clear().position(offset)).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static IntBuffer slice(IntBuffer buf, int offset)
-	{
-		return ((IntBuffer)buf.clear().position(offset)).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static LongBuffer slice(LongBuffer buf, int offset)
-	{
-		return ((LongBuffer)buf.clear().position(offset)).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static FloatBuffer slice(FloatBuffer buf, int offset)
-	{
-		return ((FloatBuffer)buf.clear().position(offset)).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static DoubleBuffer slice(DoubleBuffer buf, int offset)
-	{
-		return ((DoubleBuffer)buf.clear().position(offset)).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static ByteBuffer slice(byte[] buf, int offset)
-	{
-		return ByteBuffer.wrap(buf, offset, buf.length - offset)
-				.slice().order(nativeOrder);
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static CharBuffer slice(char[] buf, int offset)
-	{
-		return CharBuffer.wrap(buf, offset, buf.length - offset).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static ShortBuffer slice(short[] buf, int offset)
-	{
-		return ShortBuffer.wrap(buf, offset, buf.length - offset).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static IntBuffer slice(int[] buf, int offset)
-	{
-		return IntBuffer.wrap(buf, offset, buf.length - offset).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static LongBuffer slice(long[] buf, int offset)
-	{
-		return LongBuffer.wrap(buf, offset, buf.length - offset).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static FloatBuffer slice(float[] buf, int offset)
-	{
-		return FloatBuffer.wrap(buf, offset, buf.length - offset).slice();
-	}
-
-	/**
-	 * Creates a new buffer whose content is a shared subsequence of a buffer.
-	 * <p>The content of the new buffer will start at the specified offset.
-	 * @param buf    buffer
-	 * @param offset offset
-	 * @return the new buffer.
-	 */
-	public static DoubleBuffer slice(double[] buf, int offset)
-	{
-		return DoubleBuffer.wrap(buf, offset, buf.length - offset).slice();
-	}
-
-} // MPI
diff --git a/ompi/mpi/java/java/MPIException.java b/ompi/mpi/java/java/MPIException.java
deleted file mode 100644
index fb6c7744f0c..00000000000
--- a/ompi/mpi/java/java/MPIException.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : MPIException.java
- * Author       : Bryan Carpenter
- * Created      : Tue Sep 14 13:03:57 EDT 1999
- * Revision     : $Revision: 1.1 $
- * Updated      : $Date: 1999/09/14 22:01:52 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1999
- *
- * Sidenote from August 2020: this class probably should have been
- * called MPIError, not MPIException.
- */
-
-package mpi;
-
-/**
- * Signals that an MPI error of some sort has occurred.
- * <p>The Java binding of the MPI operation {@code MPI_Error_string} is the
- * method {@code getMessage}, which is inherited from the class Exception.
- */
-public final class MPIException extends Exception
-{
-	private int errorCode, errorClass;
-
-	protected MPIException(int code, int clazz, String message)
-	{
-		super(message);
-		errorCode  = code;
-		errorClass = clazz;
-	}
-
-	/**
-	 * Creates an exception.
-	 * @param message message associated to the error
-	 */
-	public MPIException(String message)
-	{
-		super(message);
-	}
-
-	/**
-	 * Creates an exception:
-	 * @param cause cause associated to the error
-	 */
-	public MPIException(Throwable cause)
-	{
-		super(cause);
-		setStackTrace(cause.getStackTrace());
-	}
-
-	/**
-	 * Gets the MPI error code.
-	 * @return error code
-	 */
-	public int getErrorCode()
-	{
-		return errorCode;
-	}
-
-	/**
-	 * Gets the MPI error class.
-	 * @return error class
-	 */
-	public int getErrorClass()
-	{
-		return errorClass;
-	}
-
-} // MPIException
diff --git a/ompi/mpi/java/java/Makefile.am b/ompi/mpi/java/java/Makefile.am
deleted file mode 100644
index eb818ea0eeb..00000000000
--- a/ompi/mpi/java/java/Makefile.am
+++ /dev/null
@@ -1,220 +0,0 @@
-# -*- makefile -*-
-#
-# Copyright (c) 2011-2018 Cisco Systems, Inc.  All rights reserved
-# Copyright (c) 2015      Los Alamos National Security, LLC. All rights
-#                         reserved.
-# Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
-# Copyright (c) 2018      Research Organization for Information Science
-#                         and Technology (RIST).  All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-include $(top_srcdir)/Makefile.ompi-rules
-
-#
-# We generate three general things in this directory:
-#
-# 1. *.java files get compiled into mpi/*.class files.
-# 2. The mpi/*.class files are then assembled into an mpi.jar file.
-# 3. The mpi/*.class files are analyzed to make *.h JNI files.
-#
-
-# These are the Java source files.  However, Automake doesn't directly
-# know about them, and we compile them via *.java below (ick!).  So we
-# just list them here in EXTRA_DIST so that they get picked up by
-# "make dist".
-JAVA_SRC_FILES = \
-	CartComm.java     \
-	CartParms.java    \
-	Comm.java         \
-	Constant.java     \
-	Count.java	  \
-	Datatype.java     \
-	DistGraphNeighbors.java \
-	DoubleInt.java    \
-	DoubleComplex.java \
-	Errhandler.java   \
-	FloatComplex.java \
-	FloatInt.java     \
-	File.java         \
-	FileView.java     \
-	Freeable.java     \
-	GraphComm.java    \
-	GraphParms.java   \
-	Group.java        \
-	Info.java	  \
-	Int2.java         \
-	Intercomm.java    \
-	Intracomm.java    \
-	LongInt.java      \
-	Message.java      \
-	MPI.java          \
-	MPIException.java \
-	Op.java           \
-	Prequest.java     \
-	Request.java      \
-	ShiftParms.java   \
-	ShortInt.java     \
-	Status.java       \
-	Struct.java       \
-	UserFunction.java \
-	Version.java	  \
-	Win.java
-
-EXTRA_DIST = $(JAVA_SRC_FILES)
-
-# Only do this stuff if we want the Java bindings
-if OMPI_WANT_JAVA_BINDINGS
-
-# These files get generated.  They have a 1:1 correspondence to .java
-# files, but there is not a .h file for every .java file.  That's why
-# we have a specific list of files here, as opposed to deriving them
-# from JAVA_SRC_FILES.
-JAVA_H = \
-	mpi_MPI.h          \
-	mpi_CartComm.h     \
-	mpi_Comm.h         \
-	mpi_Constant.h     \
-	mpi_Count.h        \
-	mpi_Datatype.h     \
-	mpi_Errhandler.h   \
-	mpi_File.h         \
-	mpi_GraphComm.h    \
-	mpi_Group.h        \
-	mpi_Info.h         \
-	mpi_Intercomm.h    \
-	mpi_Intracomm.h    \
-	mpi_Message.h      \
-	mpi_Op.h           \
-	mpi_Prequest.h     \
-	mpi_Request.h      \
-	mpi_Status.h       \
-	mpi_Win.h
-
-# A little verbosity magic; see Makefile.ompi-rules for an explanation.
-OMPI_V_JAVAC = $(ompi__v_JAVAC_$V)
-ompi__v_JAVAC_ = $(ompi__v_JAVAC_$AM_DEFAULT_VERBOSITY)
-ompi__v_JAVAC_0 = @echo "  JAVAC   " `basename $@`;
-
-OMPI_V_JAVAH = $(ompi__v_JAVAH_$V)
-ompi__v_JAVAH_ = $(ompi__v_JAVAH_$AM_DEFAULT_VERBOSITY)
-ompi__v_JAVAH_0 = @echo "  JAVAH   " `basename $@`;
-
-OMPI_V_JAR = $(ompi__v_JAR_$V)
-ompi__v_JAR_ = $(ompi__v_JAR_$AM_DEFAULT_VERBOSITY)
-ompi__v_JAR_0 = @echo "    JAR   " `basename $@`;
-
-OMPI_V_JAVADOC = $(ompi__v_JAVADOC_$V)
-ompi__v_JAVADOC_ = $(ompi__v_JAVADOC_$AM_DEFAULT_VERBOSITY)
-ompi__v_JAVADOC_0 = @echo "JAVADOC   " `basename $@`;
-
-OMPI_V_JAVADOC_QUIET = $(ompi__v_JAVADOC_QUIET_$V)
-ompi__v_JAVADOC_QUIET_ = $(ompi__v_JAVADOC_QUIET_$AM_DEFAULT_VERBOSITY)
-ompi__v_JAVADOC_QUIET_0 = -quiet
-
-# All the .java files seem to have circular references, such that I
-# can't figure out a linear order in which to compile them
-# sequentially that does not generate dependency errors.  Hence, the
-# only way I can figure out how to compile them is via *.java -- this
-# could well be due to my own misunderstanding of Java or the
-# compiler.  Shrug.
-#
-# So instead of listing all the .class files, since the rule below
-# will generate *all* the .class files simulanteously, just use
-# mpi/MPI.class as a token class file for both the rule and all the
-# dependencies below.
-#
-# Note too, that all of them will be recompiled if any of them change,
-# since Automake doesn't know how to automatically generate
-# dependencies for Java source files.  So I made the token MPI.class
-# file dependent upon *all* the .java source files.
-#
-# Note that the javac compile will generate all the .class files in
-# the "mpi" subdirectory, because that's the java package that they're
-# in.  This, along with the fact that the .java files seem to have
-# circular references, prevents us from using a .foo.bar: generic
-# Makefile rule. :-(
-if OMPI_HAVE_JAVAH_SUPPORT
-mpi/MPI.class: $(JAVA_SRC_FILES)
-	$(OMPI_V_JAVAC) CLASSPATH=. ; \
-	export CLASSPATH ; \
-	$(JAVAC) -d . $(top_srcdir)/ompi/mpi/java/java/*.java
-
-# Similar to above, all the generated .h files are dependent upon the
-# token mpi/MPI.class file.  Hence, all the classes will be generated
-# first, then we'll individually generate each of the .h files.
-
-$(JAVA_H): mpi/MPI.class
-	$(OMPI_V_JAVAH) sourcename=mpi.`echo $@ | sed -e s/^mpi_// -e s/.h$$//`; \
-	CLASSPATH=. ; \
-	export CLASSPATH ; \
-	$(JAVAH) -d . -jni $$sourcename
-else
-mpi/MPI.class: $(JAVA_SRC_FILES)
-	$(OMPI_V_JAVAC) CLASSPATH=. ; \
-	export CLASSPATH ; \
-	$(JAVAC) -h . -d . $(top_srcdir)/ompi/mpi/java/java/*.java
-endif # OMPI_HAVE_JAVAH_SUPPORT
-
-# Generate the .jar file from all the class files.  List mpi/MPI.class
-# as a dependency so that it fires the rule above that will generate
-# *all* the mpi/*.class files.
-mpi.jar: mpi/MPI.class
-	$(OMPI_V_JAR) $(JAR) cf mpi.jar mpi/*.class
-
-# Install the jar file into libdir.  Use the DATA Automake primary,
-# because Automake will complain if you try to use LIBRARIES with a
-# filename that doesn't fit the lib<foo>.* format.  Also use an
-# indirection to get to the libdir -- Automake does not allow putting
-# libdir for the DATA primary.
-javadir = $(libdir)
-java_DATA = mpi.jar
-
-# List all the header files in BUILT_SOURCES so that Automake's "all"
-# target will build them.  This will also force the building of the
-# mpi/*.class files (for the jar file).
-if OMPI_HAVE_JAVAH_SUPPORT
-BUILT_SOURCES = $(JAVA_H) doc
-else
-BUILT_SOURCES = mpi/MPI.class doc
-endif
-
-# Convenience for building Javadoc docs
-jdoc: doc
-
-# Make the "doc" target (and subdir) dependent upon mpi/MPI.class; if
-# mpi.jar is ever rebuilt, then also make the docs eligible to be
-# rebuilt.
-doc: mpi/MPI.class
-	$(OMPI_V_JAVADOC) $(JAVADOC) $(OMPI_V_JAVADOC_QUIET) -d doc $(srcdir)/*.java
-	@touch doc
-
-jdoc-install: doc
-	-$(MKDIR_P) $(DESTDIR)$(docdir)/javadoc-openmpi
-	cp -rp doc/* $(DESTDIR)$(docdir)/javadoc-openmpi
-
-jdoc-uninstall:
-	-rm -rf $(DESTDIR)$(docdir)/javadoc
-
-install-data-hook: jdoc-install
-uninstall-local: jdoc-uninstall
-
-# Clean up all the things that this Makefile.am generates.
-CLEANFILES += $(JAVA_H) mpi.jar
-
-# Can only put *files* in CLEANFILES; need to remove the generated doc
-# and mpi directories separately.
-clean-local:
-	-rm -rf doc mpi
-
-# Conditionally install the header files
-if WANT_INSTALL_HEADERS
-ompihdir = $(ompiincludedir)/$(subdir)
-nobase_nodist_ompih_HEADERS = $(JAVA_H)
-endif
-
-endif
diff --git a/ompi/mpi/java/java/Message.java b/ompi/mpi/java/java/Message.java
deleted file mode 100644
index a88974a6267..00000000000
--- a/ompi/mpi/java/java/Message.java
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * IMPLEMENTATION DETAILS
- *
- * All methods with buffers that can be direct or non direct have
- * a companion argument 'db' which is true if the buffer is direct.
- *
- * Checking if a buffer is direct is faster in Java than C.
- */
-
-package mpi;
-
-import java.nio.*;
-import static mpi.MPI.assertDirectBuffer;
-
-/**
- * This class represents {@code MPI_Message}.
- */
-public final class Message
-{
-	protected long handle;
-	private static long NULL, NO_PROC;
-
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	/**
-	 * Creates a {@code MPI_MESSAGE_NULL}.
-	 */
-	public Message()
-	{
-		handle = NULL;
-	}
-
-	/**
-	 * Tests if the message is {@code MPI_MESSAGE_NULL}.
-	 * @return true if the message is {@code MPI_MESSAGE_NULL}.
-	 */
-	public boolean isNull()
-	{
-		return handle == NULL;
-	}
-
-	/**
-	 * Tests if the message is {@code MPI_MESSAGE_NO_PROC}.
-	 * @return true if the message is {@code MPI_MESSAGE_NO_PROC}.
-	 */
-	public boolean isNoProc()
-	{
-		return handle == NO_PROC;
-	}
-
-	/**
-	 * Java binding of {@code MPI_MPROBE}.
-	 * @param source rank of the source
-	 * @param tag    message tag
-	 * @param comm   communicator
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status mProbe(int source, int tag, Comm comm) throws MPIException
-	{
-		MPI.check();
-		Status status = new Status();
-		handle = mProbe(source, tag, comm.handle, status.data);
-		return status;
-	}
-
-	private native long mProbe(int source, int tag, long comm, long[] status)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_IMPROBE}.
-	 * @param source rank of the source
-	 * @param tag    message tag
-	 * @param comm   communicator
-	 * @return status object if there is a message, {@code null} otherwise
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status imProbe(int source, int tag, Comm comm) throws MPIException
-	{
-		MPI.check();
-		return imProbe(source, tag, comm.handle);
-	}
-
-	private native Status imProbe(int source, int tag, long comm)
-			throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_MRECV}.
-	 * @param buf   receive buffer
-	 * @param count number of elements in receive buffer
-	 * @param type  datatype of each receive buffer element
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Status mRecv(Object buf, int count, Datatype type) throws MPIException
-	{
-		MPI.check();
-		int off = 0;
-		boolean db = false;
-		Status status = new Status();
-
-		if(buf instanceof Buffer && !(db = ((Buffer)buf).isDirect()))
-		{
-			off = type.getOffset(buf);
-			buf = ((Buffer)buf).array();
-		}
-
-		handle = mRecv(handle, buf, db, off, count,
-				type.handle, type.baseType, status.data);
-
-		return status;
-	}
-
-	private native long mRecv(
-			long message, Object buf, boolean db, int offset, int count,
-			long type, int baseType, long[] status) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_IMRECV}.
-	 * @param buf   receive buffer
-	 * @param count number of elements in receive buffer
-	 * @param type  datatype of each receive buffer element
-	 * @return request object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request imRecv(Buffer buf, int count, Datatype type)
-			throws MPIException
-	{
-		MPI.check();
-		assertDirectBuffer(buf);
-		Request req = new Request(imRecv(handle, buf, count, type.handle));
-		req.addRecvBufRef(buf);
-		return req;
-	}
-
-	private native long imRecv(long message, Object buf, int count, long type)
-			throws MPIException;
-
-} // Message
diff --git a/ompi/mpi/java/java/Op.java b/ompi/mpi/java/java/Op.java
deleted file mode 100644
index f7dd25a25b0..00000000000
--- a/ompi/mpi/java/java/Op.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Op.java
- * Author       : Xinying Li, Sang LIm
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.11 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-import java.nio.*;
-
-/**
- * This class represents {@code MPI_Op}.
- */
-public final class Op implements Freeable
-{
-	protected final UserFunction uf;
-	private boolean commute;
-	private Datatype datatype;
-	protected long handle;
-
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	protected Op(int type)
-	{
-		getOp(type);
-		uf = null;
-		commute = true;
-	}
-
-	private native void getOp(int type);
-
-	/**
-	 * Bind a user-defined global reduction operation to an {@code Op} object.
-	 * <p>Java binding of the MPI operation {@code MPI_OP_CREATE}.
-	 * @param function user defined function
-	 * @param commute  {@code true} if commutative, {@code false} otherwise
-	 */
-	public Op(UserFunction function, boolean commute)
-	{
-		handle = 0; // When JNI code gets the handle it will be initialized.
-		uf = function;
-		this.commute = commute;
-	}
-
-	protected void setDatatype(Datatype t)
-	{
-		datatype = t;
-	}
-
-	protected void call(Object invec, Object inoutvec, int count)
-			throws MPIException
-	{
-		if(datatype.baseType == Datatype.BOOLEAN)
-		{
-			uf.call(invec, inoutvec, count, datatype);
-		}
-		else
-		{
-			uf.call(((ByteBuffer)invec).order(ByteOrder.nativeOrder()),
-					((ByteBuffer)inoutvec).order(ByteOrder.nativeOrder()),
-					count, datatype);
-		}
-	}
-
-	/**
-	 * Test if the operation is commutative.
-	 * <p>Java binding of the MPI operation {@code MPI_OP_COMMUTATIVE}.
-	 * @return {@code true} if commutative, {@code false} otherwise
-	 */
-	public boolean isCommutative()
-	{
-		return commute;
-	}
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_OP_FREE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public native void free() throws MPIException;
-
-	/**
-	 * Test if operation object is null.
-	 * @return true if the operation object is null, false otherwise
-	 */
-	public native boolean isNull();
-
-} // Op
diff --git a/ompi/mpi/java/java/Prequest.java b/ompi/mpi/java/java/Prequest.java
deleted file mode 100644
index 205e0d489a0..00000000000
--- a/ompi/mpi/java/java/Prequest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Prequest.java
- * Author       : Sang Lim, Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.11 $
- * Updated      : $Date: 2001/10/22 21:07:55 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * Persistent request object.
- */
-public final class Prequest extends Request
-{
-	/**
-	 * Constructor used by {@code sendInit}, etc.
-	 * @param handle	Handle for the Prequest object
-	 */
-	protected Prequest(long handle)
-	{
-		super(handle);
-	}
-
-	/**
-	 * Activate a persistent communication request.
-	 * <p>Java binding of the MPI operation {@code MPI_START}.
-	 * The communication is completed by using the request in
-	 * one of the {@code wait} or {@code test} operations.
-	 * On successful completion the request becomes inactive again.
-	 * It can be reactivated by a further call to {@code Start}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void start() throws MPIException
-	{
-		handle = start(handle);
-	}
-
-	private native long start(long request) throws MPIException;
-
-	/**
-	 * Activate a list of communication requests.
-	 * <p>Java binding of the MPI operation {@code MPI_STARTALL}.
-	 * @param requests array of requests
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void startAll(Prequest[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		startAll(r);
-		setHandles(requests, r);
-	}
-
-	private native static void startAll(long[] requests) throws MPIException;
-
-} // Prequest
diff --git a/ompi/mpi/java/java/Request.java b/ompi/mpi/java/java/Request.java
deleted file mode 100644
index eb841731af3..00000000000
--- a/ompi/mpi/java/java/Request.java
+++ /dev/null
@@ -1,522 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- * File         : Request.java
- * Author       : Sang Lim, Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.11 $
- * Updated      : $Date: 2001/08/07 16:36:25 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- *
- *
- *
- * Note: in a send request for a buffer containing objects, the primary
- * `MPI_Request' referenced by `handle' is the request to send the data.
- * The request to send the header is in the secondary field, `hdrReq'.
- * Conversely, in a *receive* request for a buffer containing objects
- * the primary `MPI_Request' is the request to send the header.
- * The receive of the data is not initiated until a `wait' or `test'
- * operation succeeds.
- *
- *
- *
- * Probably `Request' should be an abstract class, and there should
- * be several concrete subclasses.  At the moment requests are created
- * in a few different ways, and the differently constructed requests are
- * typically using different subsets of fields.  DBC 7/12/01
- */
-
-package mpi;
-
-import java.nio.Buffer;
-
-/**
- * Request object.
- */
-public class Request implements Freeable
-{
-	protected long handle;
-	protected Buffer sendBuf;
-	protected Buffer recvBuf;
-
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	protected static native long getNull();
-
-	protected Request(long handle)
-	{
-		this.handle = handle;
-	}
-
-	/**
-	 * Set the request object to be void.
-	 * Java binding of the MPI operation {@code MPI_REQUEST_FREE}.
-	 */
-	@Override public void free() throws MPIException
-	{
-		if(!isNull())
-		{
-			MPI.check();
-			handle = free(handle);
-		}
-	}
-
-	private native long free(long req) throws MPIException;
-
-	/**
-	 * Mark a pending nonblocking communication for cancellation.
-	 * Java binding of the MPI operation {@code MPI_CANCEL}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void cancel() throws MPIException
-	{
-		MPI.check();
-		cancel(handle);
-	}
-
-	private native void cancel(long request) throws MPIException;
-
-	/**
-	 * Adds a receive buffer to this Request object.  This method
-	 * should be called by the internal api whenever a persistent
-	 * request is created and any time a request object, that has
-	 * an associated buffer, is returned from an operation to protect
-	 * the buffer from getting prematurely garbage collected.
-	 * @param buf buffer to add to the array list
-	 */
-	protected final void addRecvBufRef(Buffer buf)
-	{
-		this.recvBuf = buf;
-	}
-
-	/**
-	 * Adds a send buffer to this Request object.  This method
-	 * should be called by the internal api whenever a persistent
-	 * request is created and any time a request object, that has
-	 * an associated buffer, is returned from an operation to protect
-	 * the buffer from getting prematurely garbage collected.
-	 * @param buf buffer to add to the array list
-	 */
-	protected final void addSendBufRef(Buffer buf)
-	{
-		this.sendBuf = buf;
-	}
-
-	/**
-	 * Test if request object is null.
-	 * @return true if the request object is null, false otherwise
-	 */
-	public final boolean isNull()
-	{
-		return handle == 0 || handle == MPI.REQUEST_NULL.handle;
-	}
-
-	/**
-	 * Blocks until the operation identified by the request is complete.
-	 * <p>Java binding of the MPI operation {@code MPI_WAIT}.
-	 * <p>After the call returns, the request object becomes inactive.
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Status waitStatus() throws MPIException
-	{
-		MPI.check();
-		Status status = new Status();
-		handle = waitStatus(handle, status.data);
-		return status;
-	}
-
-	private native long waitStatus(long request, long[] stat) throws MPIException;
-
-	/**
-	 * Blocks until the operation identified by the request is complete.
-	 * <p>Java binding of the MPI operation {@code MPI_WAIT}.
-	 * <p>After the call returns, the request object becomes inactive.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final void waitFor() throws MPIException
-	{
-		MPI.check();
-		handle = waitFor(handle);
-	}
-
-	private native long waitFor(long request) throws MPIException;
-
-	/**
-	 * Returns a status object if the operation identified by the request
-	 * is complete, or a null reference otherwise.
-	 * <p>Java binding of the MPI operation {@code MPI_TEST}.
-	 * <p>After the call, if the operation is complete (ie, if the return
-	 * value is non-null), the request object becomes inactive.
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Status testStatus() throws MPIException
-	{
-		MPI.check();
-		return testStatus(handle);
-	}
-
-	private native Status testStatus(long request) throws MPIException;
-
-	/**
-	 * Returns a status object if the operation identified by the request
-	 * is complete, or a null reference otherwise.
-	 * <p>Java binding of the MPI operation {@code MPI_REQUEST_GET_STATUS}.
-	 * <p>After the call, if the operation is complete (ie, if the return
-	 * value is non-null), the request object remains active.
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Status getStatus() throws MPIException
-	{
-		MPI.check();
-		return getStatus(handle);
-	}
-
-	private native Status getStatus(long request) throws MPIException;
-
-	/**
-	 * Returns true if the operation identified by the request
-	 * is complete, or false otherwise.
-	 * <p>Java binding of the MPI operation {@code MPI_TEST}.
-	 * <p>After the call, if the operation is complete (ie, if the return
-	 * value is true), the request object becomes inactive.
-	 * @return true if the operation identified by the request, false otherwise
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final boolean test() throws MPIException
-	{
-		MPI.check();
-		return test(handle);
-	}
-
-	private native boolean test(long handle) throws MPIException;
-
-	/**
-	 * Blocks until one of the operations associated with the active
-	 * requests in the array has completed.
-	 * <p>Java binding of the MPI operation {@code MPI_WAITANY}.
-	 * <p>The index in array of {@code requests} for the request that
-	 * completed can be obtained from the returned status object through
-	 * the {@code Status.getIndex()} method. The corresponding element
-	 * of array of {@code requests} becomes inactive.
-	 * @param requests array of requests
-	 * @return status object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Status waitAnyStatus(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		Status status = new Status();
-		waitAnyStatus(r, status.data);
-		setHandles(requests, r);
-		return status;
-	}
-
-	private static native void waitAnyStatus(long[] requests, long[] status)
-			throws MPIException;
-
-	/**
-	 * Blocks until one of the operations associated with the active
-	 * requests in the array has completed.
-	 * <p>Java binding of the MPI operation {@code MPI_WAITANY}.
-	 * <p>The request that completed becomes inactive.
-	 * @param requests array of requests
-	 * @return The index in array of {@code requests} for the request that
-	 * completed. If all of the requests are MPI_REQUEST_NULL, then index
-	 * is returned as {@code MPI.UNDEFINED}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int waitAny(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		int index = waitAny(r);
-		setHandles(requests, r);
-		return index;
-	}
-
-	private static native int waitAny(long[] requests) throws MPIException;
-
-	/**
-	 * Tests for completion of either one or none of the operations
-	 * associated with active requests.
-	 * <p>Java binding of the MPI operation {@code MPI_TESTANY}.
-	 * <p>If some request completed, the index in array of {@code requests}
-	 * for that request can be obtained from the returned status object.
-	 * The corresponding element in array of {@code requests} becomes inactive.
-	 * If no request completed, {@code testAnyStatus} returns {@code null}.
-	 * @param requests array of requests
-	 * @return status object if one request completed, {@code null} otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Status testAnyStatus(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		Status status = testAnyStatus(r);
-		setHandles(requests, r);
-		return status;
-	}
-
-	private static native Status testAnyStatus(long[] requests) throws MPIException;
-
-	/**
-	 * Tests for completion of either one or none of the operations
-	 * associated with active requests.
-	 * <p>Java binding of the MPI operation {@code MPI_TESTANY}.
-	 * <p>If some request completed, it becomes inactive.
-	 * @param requests array of requests
-	 * @return index of operation that completed, or {@code MPI.UNDEFINED}
-	 * if none completed.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int testAny(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		int index = testAny(r);
-		setHandles(requests, r);
-		return index;
-	}
-
-	private static native int testAny(long[] requests) throws MPIException;
-
-	/**
-	 * Blocks until all of the operations associated with the active
-	 * requests in the array have completed.
-	 * <p>Java binding of the MPI operation {@code MPI_WAITALL}.
-	 * <p>On exit, requests become inactive.  If the <em>input</em> value of
-	 * array of {@code requests} contains inactive requests, corresponding
-	 * elements of the status array will contain null status references.
-	 * @param requests array of requests
-	 * @return array of statuses
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Status[] waitAllStatus(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		Status[] status = waitAllStatus(r);
-		setHandles(requests, r);
-		return status;
-	}
-
-	private static native Status[] waitAllStatus(long[] requests)
-			throws MPIException;
-
-	/**
-	 * Blocks until all of the operations associated with the active
-	 * requests in the array have completed.
-	 * <p>Java binding of the MPI operation {@code MPI_WAITALL}.
-	 * @param requests array of requests
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void waitAll(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		waitAll(r);
-		setHandles(requests, r);
-	}
-
-	private static native void waitAll(long[] requests) throws MPIException;
-
-	/**
-	 * Tests for completion of <em>all</em> of the operations associated
-	 * with active requests.
-	 * <p>Java binding of the MPI operation {@code MPI_TESTALL}.
-	 * <p>If all operations have completed, the exit value of the argument array
-	 * is as for {@code waitAllStatus}.
-	 * @param requests array of requests
-	 * @return array of statuses if all operations have completed,
-	 *         {@code null} otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Status[] testAllStatus(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		Status[] status = testAllStatus(r);
-		setHandles(requests, r);
-		return status;
-	}
-
-	private static native Status[] testAllStatus(long[] requests)
-			throws MPIException;
-
-	/**
-	 * Tests for completion of <em>all</em> of the operations associated
-	 * with active requests.
-	 * <p>Java binding of the MPI operation {@code MPI_TESTALL}.
-	 * @param requests array of requests
-	 * @return {@code true} if all operations have completed,
-	 *         {@code false} otherwise.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static boolean testAll(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		boolean completed = testAll(r);
-		setHandles(requests, r);
-		return completed;
-	}
-
-	private static native boolean testAll(long[] requests) throws MPIException;
-
-	/**
-	 * Blocks until at least one of the operations associated with the active
-	 * requests in the array has completed.
-	 * <p>Java binding of the MPI operation {@code MPI_WAITSOME}.
-	 * <p>The size of the result array will be the number of operations that
-	 * completed. The index in array of {@code requests} for each request that
-	 * completed can be obtained from the returned status objects through the
-	 * {@code Status.getIndex()} method. The corresponding element in
-	 * array of {@code requests} becomes inactive.
-	 * @param requests array of requests
-	 * @return array of statuses or {@code null} if the number of operations
-	 *         completed is {@code MPI_UNDEFINED}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Status[] waitSomeStatus(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		Status[] status = waitSomeStatus(r);
-		setHandles(requests, r);
-		return status;
-	}
-
-	private static native Status[] waitSomeStatus(long[] requests)
-			throws MPIException;
-
-	/**
-	 * Blocks until at least one of the operations associated with the active
-	 * active requests in the array has completed.
-	 * <p>Java binding of the MPI operation {@code MPI_WAITSOME}.
-	 * <p>The size of the result array will be the number of operations that
-	 * completed. The corresponding element in array of {@code requests} becomes
-	 * inactive.
-	 * @param requests array of requests
-	 * @return array of indexes of {@code requests} that completed or {@code null}
-	 *         if the number of operations completed is {@code MPI_UNDEFINED}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int[] waitSome(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		int[] indexes = waitSome(r);
-		setHandles(requests, r);
-		return indexes;
-	}
-
-	private static native int[] waitSome(long[] requests) throws MPIException;
-
-	/**
-	 * Behaves like {@code waitSome}, except that it returns immediately.
-	 * <p>Java binding of the MPI operation {@code MPI_TESTSOME}.
-	 * <p>If no operation has completed, {@code testSome} returns an array of
-	 * length zero, otherwise the return value are as for {@code waitSome}.
-	 * @param requests array of requests
-	 * @return array of statuses
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static Status[] testSomeStatus(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		Status[] status = testSomeStatus(r);
-		setHandles(requests, r);
-		return status;
-	}
-
-	private static native Status[] testSomeStatus(long[] requests)
-			throws MPIException;
-
-	/**
-	 * Behaves like {@code waitSome}, except that it returns immediately.
-	 * <p>Java binding of the MPI operation {@code MPI_TESTSOME}.
-	 * <p>If no operation has completed, {@code testSome} returns an array of
-	 * length zero, otherwise the return value are as for {@code waitSome}.
-	 * @param requests array of requests
-	 * @return array of indexes of {@code requests} that completed.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int[] testSome(Request[] requests) throws MPIException
-	{
-		MPI.check();
-		long[] r = getHandles(requests);
-		int[] indexes = testSome(r);
-		setHandles(requests, r);
-		return indexes;
-	}
-
-	private static native int[] testSome(long[] requests) throws MPIException;
-
-	protected static long[] getHandles(Request[] r)
-	{
-		long[] h = new long[r.length];
-
-		for(int i = 0; i < r.length; i++) {
-			if(r[i] != null)
-				h[i] = r[i].handle;
-			else
-				h[i] = 0;
-		}
-
-		return h;
-	}
-
-	protected static void setHandles(Request[] r, long[] h)
-	{
-		for(int i = 0; i < r.length; i++)
-			r[i].handle = h[i];
-	}
-
-} // Request
diff --git a/ompi/mpi/java/java/ShiftParms.java b/ompi/mpi/java/java/ShiftParms.java
deleted file mode 100644
index 49ddc72014f..00000000000
--- a/ompi/mpi/java/java/ShiftParms.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : ShiftParms.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.1 $
- * Updated      : $Date: 1998/08/26 18:50:05 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * Source and destination ranks for "shift" communication.
- */
-public final class ShiftParms
-{
-	private final int rankSource;
-	private final int rankDest;
-
-	protected ShiftParms(int rankSource, int rankDest)
-	{
-		this.rankSource = rankSource;
-		this.rankDest   = rankDest;
-	}
-
-	/**
-	 * Gets the source rank.
-	 * @return source rank
-	 */
-	public int getRankSource()
-	{
-		return rankSource;
-	}
-
-	/**
-	 * Gets the destination rank.
-	 * @return destination rank
-	 */
-	public int getRankDest()
-	{
-		return rankDest;
-	}
-
-} // ShiftParms
diff --git a/ompi/mpi/java/java/ShortInt.java b/ompi/mpi/java/java/ShortInt.java
deleted file mode 100644
index 18c1a421f05..00000000000
--- a/ompi/mpi/java/java/ShortInt.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-/**
- * Struct class for {@link MPI#SHORT_INT} datatype.
- */
-public final class ShortInt extends Struct
-{
-	private final int sSize, iOff, iSize;
-
-	/**
-	 * The struct object will be created only in MPI class.
-	 * @param shortSize	short size
-	 * @param intOff	int offset
-	 * @param intSize	int size
-	 * @see MPI#shortInt
-	 */
-	protected ShortInt(int shortSize, int intOff, int intSize)
-	{
-		sSize = shortSize;
-		iSize = intSize;
-		int sOff;
-
-		switch(sSize)
-		{
-		case 2: sOff = addShort(); break;
-		case 4: sOff = addInt();   break;
-		case 8: sOff = addLong();  break;
-		default: throw new AssertionError("Unsupported short size: "+ sSize);
-		}
-
-		assert sOff == 0;
-		setOffset(intOff);
-
-		switch(iSize)
-		{
-		case 4: iOff = addInt();  break;
-		case 8: iOff = addLong(); break;
-		default: throw new AssertionError("Unsupported int size: "+ iSize);
-		}
-
-		assert(intOff == iOff);
-	}
-
-	/**
-	 * Creates a Data object.
-	 * @return new Data object.
-	 */
-	@Override protected Data newData()
-	{
-		return new Data();
-	}
-
-	/**
-	 * Class for reading/writing data in a struct stored in a byte buffer.
-	 */
-	public final class Data extends Struct.Data
-	{
-		/**
-		 * Gets the short value.
-		 * @return short value
-		 */
-		public short getValue()
-		{
-			switch(sSize)
-			{
-			case 2: return getShort(0);
-			case 4: return (short)getInt(0);
-			case 8: return (short)getLong(0);
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Gets the int value.
-		 * @return int value
-		 */
-		public int getIndex()
-		{
-			switch(iSize)
-			{
-			case 4: return getInt(iOff);
-			case 8: return (int)getLong(iOff);
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Puts the short value.
-		 * @param v short value
-		 */
-		public void putValue(short v)
-		{
-			switch(sSize)
-			{
-			case 2: putShort(0, v); break;
-			case 4: putInt(0, v);   break;
-			case 8: putLong(0, v);  break;
-			default: throw new AssertionError();
-			}
-		}
-
-		/**
-		 * Puts the int value.
-		 * @param v int value
-		 */
-		public void putIndex(int v)
-		{
-			switch(iSize)
-			{
-			case 4: putInt(iOff, v);  break;
-			case 8: putLong(iOff, v); break;
-			default: throw new AssertionError();
-			}
-		}
-	} // Data
-
-} // ShortInt
diff --git a/ompi/mpi/java/java/Status.java b/ompi/mpi/java/java/Status.java
deleted file mode 100644
index eaeb467cf58..00000000000
--- a/ompi/mpi/java/java/Status.java
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Status.java
- * Author       : Sang Lim, Sung-Hoon Ko, Xinying Li, Bryan Carpenter
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.15 $
- * Updated      : $Date: 2003/01/16 16:39:34 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-/**
- * This class represents {@code MPI_Status}.
- */
-public final class Status
-{
-	protected final long[] data;
-
-	static
-	{
-		init();
-	}
-
-	private static native void init();
-
-	/**
-	 * Status objects must be created only by the MPI methods.
-	 */
-	protected Status()
-	{
-		data = new long[6];
-	}
-
-	/**
-	 * Returns the number of received entries.
-	 * <p>Java binding of the MPI operation {@code MPI_GET_COUNT}.
-	 * @param datatype datatype of each item in receive buffer
-	 * @return number of received entries
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getCount(Datatype datatype) throws MPIException
-	{
-		MPI.check();
-		int  i = 0;
-		int  source    = (int)data[i++];
-		int  tag       = (int)data[i++];
-		int  error     = (int)data[i++];
-		int  cancelled = (int)data[i++];
-		long ucount    = data[i++];
-		return getCount(source, tag, error, cancelled, ucount, datatype.handle);
-	}
-
-	private native int getCount(
-			int source, int tag, int error,
-			int cancelled, long ucount, long datatype) throws MPIException;
-
-	/**
-	 * Tests if the communication was cancelled.
-	 * <p>Java binding of the MPI operation {@code MPI_TEST_CANCELLED}.
-	 * @return true if the operation was successfully cancelled, false otherwise
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public boolean isCancelled() throws MPIException
-	{
-		MPI.check();
-		int  i = 0;
-		int  source    = (int)data[i++];
-		int  tag       = (int)data[i++];
-		int  error     = (int)data[i++];
-		int  cancelled = (int)data[i++];
-		long ucount    = data[i++];
-		return isCancelled(source, tag, error, cancelled, ucount);
-	}
-
-	private native boolean isCancelled(
-			int source, int tag, int error, int cancelled, long ucount)
-					throws MPIException;
-
-	/**
-	 * Retrieves the number of basic elements from status.
-	 * <p>Java binding of the MPI operation {@code MPI_GET_ELEMENTS}.
-	 * @param datatype datatype used by receive operation
-	 * @return number of received basic elements
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public int getElements(Datatype datatype) throws MPIException
-	{
-		MPI.check();
-		int  i = 0;
-		int  source    = (int)data[i++];
-		int  tag       = (int)data[i++];
-		int  error     = (int)data[i++];
-		int  cancelled = (int)data[i++];
-		long ucount    = data[i++];
-		return getElements(source, tag, error, cancelled, ucount, datatype.handle);
-	}
-
-	private native int getElements(
-			int source, int tag, int error,
-			int cancelled, long ucount, long datatype) throws MPIException;
-
-	/**
-	 * Retrieves the number of basic elements from status.
-	 * <p>Java binding of the MPI operation {@code MPI_GET_ELEMENTS_X}.
-	 * @param datatype datatype used by receive operation
-	 * @return number of received basic elements
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Count getElementsX(Datatype datatype) throws MPIException
-	{
-		MPI.check();
-		int  i = 0;
-		int  source    = (int)data[i++];
-		int  tag       = (int)data[i++];
-		int  error     = (int)data[i++];
-		int  cancelled = (int)data[i++];
-		long ucount    = data[i++];
-		return getElementsX(source, tag, error, cancelled, ucount, datatype.handle);
-	}
-
-	private native Count getElementsX(
-			int source, int tag, int error,
-			int cancelled, long ucount, long datatype) throws MPIException;
-
-	/**
-	 * Sets the number of basic elements for this status object.
-	 * <p>Java binding of the MPI operation {@code MPI_STATUS_SET_ELEMENTS}.
-	 * @param datatype 	datatype used by receive operation
-	 * @param count		number of elements to associate with the status
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setElements(Datatype datatype, int count) throws MPIException
-	{
-		MPI.check();
-		int  i = 0;
-		int  source    = (int)data[i++];
-		int  tag       = (int)data[i++];
-		int  error     = (int)data[i++];
-		int  cancelled = (int)data[i++];
-		long ucount    = data[i++];
-		data[4] = setElements(source, tag, error, cancelled, ucount, datatype.handle, count);
-	}
-
-	private native int setElements(
-			int source, int tag, int error,
-			int cancelled, long ucount, long datatype, int count) throws MPIException;
-
-	/**
-	 * Sets the number of basic elements for this status object.
-	 * <p>Java binding of the MPI operation {@code MPI_STATUS_SET_ELEMENTS_X}.
-	 * @param datatype 	datatype used by receive operation
-	 * @param count		number of elements to associate with the status
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setElementsX(Datatype datatype, Count count) throws MPIException
-	{
-		MPI.check();
-		int  i = 0;
-		int  source    = (int)data[i++];
-		int  tag       = (int)data[i++];
-		int  error     = (int)data[i++];
-		int  cancelled = (int)data[i++];
-		long ucount    = data[i++];
-		data[4] = setElementsX(source, tag, error, cancelled, ucount, datatype.handle, count.getCount());
-	}
-
-	private native long setElementsX(
-			int source, int tag, int error,
-			int cancelled, long ucount, long datatype, long count) throws MPIException;
-
-	/**
-	 * Sets the cancelled flag.
-	 * <p>Java binding of the MPI operation {@code MPI_STATUS_SET_CANCELLED}.
-	 * @param flag	if true indicates request was cancelled
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setCancelled(boolean flag) throws MPIException
-	{
-		MPI.check();
-		int  i = 0;
-		int  source    = (int)data[i++];
-		int  tag       = (int)data[i++];
-		int  error     = (int)data[i++];
-		int  cancelled = (int)data[i++];
-		long ucount    = data[i++];
-
-		if(flag) {
-			setCancelled(source, tag, error, cancelled, ucount, 1);
-			data[3] = 1;
-		} else {
-			setCancelled(source, tag, error, cancelled, ucount, 0);
-			data[3] = 0;
-		}
-
-	}
-
-	private native void setCancelled(
-			int source, int tag, int error,
-			int cancelled, long ucount, int flag) throws MPIException;
-
-	/**
-	 * Returns the "source" of message.
-	 * <p>Java binding of the MPI value {@code MPI_SOURCE}.
-	 * @return source of message
-	 */
-	public int getSource()
-	{
-		return (int)data[0];
-	}
-
-	/**
-	 * Returns the "tag" of message.
-	 * <p>Java binding of the MPI value {@code MPI_TAG}.
-	 * @return tag of message
-	 */
-	public int getTag()
-	{
-		return (int)data[1];
-	}
-
-	/**
-	 * Returns the {@code MPI_ERROR} of message.
-	 * @return error of message.
-	 */
-	public int getError()
-	{
-		return (int)data[2];
-	}
-
-	/**
-	 * Returns the index of message.
-	 * @return index of message.
-	 */
-	public int getIndex()
-	{
-		return (int)data[5];
-	}
-
-} // Status
diff --git a/ompi/mpi/java/java/Struct.java b/ompi/mpi/java/java/Struct.java
deleted file mode 100644
index 95e45db6bd8..00000000000
--- a/ompi/mpi/java/java/Struct.java
+++ /dev/null
@@ -1,802 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-import java.nio.*;
-import java.util.*;
-
-/**
- * Base class for defining struct data types.
- */
-public abstract class Struct
-{
-	private int extent;
-	private ArrayList<Field> fields = new ArrayList<Field>();
-
-	private Datatype datatype, types[];
-	private int offsets[], lengths[];
-	private static final String typeMismatch = "Type mismatch";
-
-	private void commit() throws MPIException
-	{
-		if(datatype == null)
-			createStruct();
-	}
-
-	private void createStruct() throws MPIException
-	{
-		int count = fields.size();
-		types   = new Datatype[count];
-		offsets = new int[count];
-		lengths = new int[count];
-
-		for(int i = 0; i < count; i++)
-		{
-			Field f = fields.get(i);
-
-			types[i] = f.type instanceof Struct ? ((Struct)f.type).datatype
-					: (Datatype)f.type;
-			offsets[i] = f.offset;
-			lengths[i] = f.length;
-		}
-
-		datatype = Datatype.createStruct(lengths, offsets, types);
-		datatype.commit();
-		extent = datatype.getExtent();
-	}
-
-	/**
-	 * Returns the extent of the struct data type.
-	 * @return Extent of the struct data type.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int getExtent() throws MPIException
-	{
-		commit();
-		return extent;
-	}
-
-	/**
-	 * Returns the data type of the struct.
-	 * @return The data type of the struct.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Datatype getType() throws MPIException
-	{
-		commit();
-		return datatype;
-	}
-
-	/**
-	 * Creates a Data object.
-	 * @return New Data object.
-	 */
-	protected abstract Data newData();
-
-	@SuppressWarnings("unchecked")
-	private <T extends Data> T newData(ByteBuffer buffer, int offset)
-	{
-		Data d = newData();
-		d.buffer = buffer;
-		d.offset = offset;
-		return (T)d;
-	}
-
-	@SuppressWarnings("javadoc")
-	/**
-	 * Gets a Data object in order to access to the buffer.
-	 * @param buffer the Data object will read/write on this buffer.
-	 * @return Data object
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final <T extends Data> T getData(ByteBuffer buffer) throws MPIException
-	{
-		commit();
-		return newData(buffer, 0);
-	}
-
-	@SuppressWarnings("javadoc")
-	/**
-	 * Gets a Data object in order to access to the struct at the
-	 * specified position of a struct array stored in a Buffer.
-	 * @param buffer The Data object will read/write on this buffer.
-	 * @param index  Index of the struct in the buffer.
-	 * @return Data object.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final <T extends Data> T getData(ByteBuffer buffer, int index)
-			throws MPIException
-	{
-		commit();
-		return newData(buffer, index * extent);
-	}
-
-	@SuppressWarnings("javadoc")
-	/**
-	 * Gets a Data object in order to access to the byte array.
-	 * @param array The Data object will read/write on this byte array.
-	 * @return Data object.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final <T extends Data> T getData(byte[] array) throws MPIException
-	{
-		ByteBuffer buffer = ByteBuffer.wrap(array);
-		buffer.order(ByteOrder.nativeOrder());
-		return getData(buffer);
-	}
-
-	@SuppressWarnings("javadoc")
-	/**
-	 * Gets a Data object in order to access to the struct at the
-	 * specified position of a struct array stored in a byte array.
-	 * @param array The Data object will read/write on this byte array.
-	 * @param index Index of the struct in the array.
-	 * @return Data object.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final <T extends Data> T getData(byte[] array, int index)
-			throws MPIException
-	{
-		ByteBuffer buffer = ByteBuffer.wrap(array);
-		buffer.order(ByteOrder.nativeOrder());
-		return getData(buffer, index);
-	}
-
-	private int addField(Object type, int typeExtent, int length)
-	{
-		if(datatype != null)
-			throw new AssertionError("The struct data type was committed.");
-
-		int offset = extent;
-		extent += typeExtent * length;
-		fields.add(new Field(type, offset, length));
-		return offset;
-	}
-
-	/**
-	 * Sets the offset of the next field.
-	 * <p>The offset must be greater or equal to the accumulated extent.
-	 * @param offset offset of the next field
-	 * @return this object in order to allow adding fields in a chained expression
-	 */
-	public final Struct setOffset(int offset)
-	{
-		if(datatype != null)
-			throw new AssertionError("The struct data type was committed.");
-
-		if(offset < extent)
-		{
-			throw new IllegalArgumentException(
-					"The offset must be greater or equal to the accumulated extent.");
-		}
-
-		extent = offset;
-		return this;
-	}
-
-	/**
-	 * Adds a byte field to this struct.
-	 * @return Offset of the new field.
-	 */
-	public final int addByte()
-	{
-		return addByte(1);
-	}
-
-	/**
-	 * Adds a byte array to this struct.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 */
-	public final int addByte(int length)
-	{
-		return addField(MPI.BYTE, 1, length);
-	}
-
-	/**
-	 * Adds a char field to this struct.
-	 * @return Offset of the new field.
-	 */
-	public final int addChar()
-	{
-		return addChar(1);
-	}
-
-	/**
-	 * Adds a char array to this struct.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 */
-	public final int addChar(int length)
-	{
-		return addField(MPI.CHAR, 2, length);
-	}
-
-	/**
-	 * Adds a short field to this struct.
-	 * @return Offset of the new field.
-	 */
-	public final int addShort()
-	{
-		return addShort(1);
-	}
-
-	/**
-	 * Adds a short array to this struct.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 */
-	public final int addShort(int length)
-	{
-		return addField(MPI.SHORT, 2, length);
-	}
-
-	/**
-	 * Adds an int field to this struct.
-	 * @return Offset of the new field.
-	 */
-	public final int addInt()
-	{
-		return addInt(1);
-	}
-
-	/**
-	 * Adds an int array to this struct.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 */
-	public final int addInt(int length)
-	{
-		return addField(MPI.INT, 4, length);
-	}
-
-	/**
-	 * Adds a long field to this struct.
-	 * @return Offset of the new field.
-	 */
-	public final int addLong()
-	{
-		return addLong(1);
-	}
-
-	/**
-	 * Adds a long array to this struct.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 */
-	public final int addLong(int length)
-	{
-		return addField(MPI.LONG, 8, length);
-	}
-
-	/**
-	 * Adds a float field to this struct.
-	 * @return Offset of the new field.
-	 */
-	public final int addFloat()
-	{
-		return addFloat(1);
-	}
-
-	/**
-	 * Adds a float array to this struct.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 */
-	public final int addFloat(int length)
-	{
-		return addField(MPI.FLOAT, 4, length);
-	}
-
-	/**
-	 * Adds a double field to this struct.
-	 * @return Offset of the new field.
-	 */
-	public final int addDouble()
-	{
-		return addDouble(1);
-	}
-
-	/**
-	 * Adds a double array to this struct.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 */
-	public final int addDouble(int length)
-	{
-		return addField(MPI.DOUBLE, 8, length);
-	}
-
-	/**
-	 * Adds a struct field to this struct.
-	 * @param struct Type of the field.
-	 * @return Offset of the new field.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int addStruct(Struct struct) throws MPIException
-	{
-		return addStruct(struct, 1);
-	}
-
-	/**
-	 * Adds an array of structs to this struct.
-	 * @param struct Type of the array.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int addStruct(Struct struct, int length) throws MPIException
-	{
-		struct.commit();
-		return addField(struct, struct.extent, length);
-	}
-
-	/**
-	 * Adds a field of the specified data type.
-	 * @param type Data type.
-	 * @return Offset of the new field.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int addData(Datatype type) throws MPIException
-	{
-		return addData(type, 1);
-	}
-
-	/**
-	 * Adds an array of the specified data type.
-	 * @param type Data type.
-	 * @param length Length of the array.
-	 * @return Offset of the new field.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final int addData(Datatype type, int length) throws MPIException
-	{
-		return addField(type, type.getExtent() * type.baseSize, length);
-	}
-
-	private boolean validType(int fieldOffset, int index, Datatype type)
-	{
-		int i = Arrays.binarySearch(offsets, fieldOffset);
-		return index >= 0 && index < lengths[i] && type == types[i];
-	}
-
-	private static class Field
-	{
-		private Object type;
-		private int offset, length;
-
-		private Field(Object type, int offset, int length)
-		{
-			this.type   = type;
-			this.offset = offset;
-			this.length = length;
-		}
-
-	} // Field
-
-	/**
-	 * Base class for reading/writing data in a struct stored in a byte buffer.
-	 */
-	public abstract class Data
-	{
-		private ByteBuffer buffer;
-		private int offset;
-
-		/**
-		 * Gets the buffer where this struct data is stored.
-		 * <p>The buffer can be used in {@code send}/{@code recv} operations.
-		 * @return Buffer where the struct data is stored.
-		 */
-		public final ByteBuffer getBuffer()
-		{
-			return offset == 0 ? buffer : MPI.slice(buffer, offset);
-		}
-
-		/**
-		 * Gets the byte value of a field.
-		 * @param field Offset of the field.
-		 * @return Byte value.
-		 */
-		protected final byte getByte(int field)
-		{
-			assert validType(field, 0, MPI.BYTE) : typeMismatch;
-			return buffer.get(offset + field);
-		}
-
-		/**
-		 * Gets the byte value at the specified position of a byte array.
-		 * @param field Offset of the byte array.
-		 * @param index Index of the byte in the array.
-		 * @return Byte value.
-		 */
-		protected final byte getByte(int field, int index)
-		{
-			assert validType(field, index, MPI.BYTE) : typeMismatch;
-			return buffer.get(offset + field + index);
-		}
-
-		/**
-		 * Puts a byte value in a field.
-		 * @param field Offset of the field.
-		 * @param v     Byte value.
-		 */
-		protected final void putByte(int field, byte v)
-		{
-			assert validType(field, 0, MPI.BYTE) : typeMismatch;
-			buffer.put(offset + field, v);
-		}
-
-		/**
-		 * Puts a byte value at the specified position of a byte array.
-		 * @param field Offset of the byte array.
-		 * @param index Index of the byte in the array.
-		 * @param v     Byte value.
-		 */
-		protected final void putByte(int field, int index, byte v)
-		{
-			assert validType(field, index, MPI.BYTE) : typeMismatch;
-			buffer.put(offset + field + index, v);
-		}
-
-		/**
-		 * Gets the char value of a field.
-		 * @param field Offset of the field.
-		 * @return Char value.
-		 */
-		protected final char getChar(int field)
-		{
-			assert validType(field, 0, MPI.CHAR) : typeMismatch;
-			return buffer.getChar(offset + field);
-		}
-
-		/**
-		 * Gets the char value at the specified position of a char array.
-		 * @param field Offset of the char array.
-		 * @param index Index of the char in the array.
-		 * @return Char value.
-		 */
-		protected final char getChar(int field, int index)
-		{
-			assert validType(field, index, MPI.CHAR) : typeMismatch;
-			return buffer.getChar(offset + field + index * 2);
-		}
-
-		/**
-		 * Puts a char value in a field.
-		 * @param field Offset of the field.
-		 * @param v     Char value.
-		 */
-		protected final void putChar(int field, char v)
-		{
-			assert validType(field, 0, MPI.CHAR) : typeMismatch;
-			buffer.putChar(offset + field, v);
-		}
-
-		/**
-		 * Puts a char value at the specified position of a char array.
-		 * @param field Offset of the char array.
-		 * @param index Index of the char in the array.
-		 * @param v     Char value.
-		 */
-		protected final void putChar(int field, int index, char v)
-		{
-			assert validType(field, index, MPI.CHAR) : typeMismatch;
-			buffer.putChar(offset + field + index * 2, v);
-		}
-
-		/**
-		 * Gets the short value of a field.
-		 * @param field Offset of the field.
-		 * @return Short value.
-		 */
-		protected final short getShort(int field)
-		{
-			assert validType(field, 0, MPI.SHORT) : typeMismatch;
-			return buffer.getShort(offset + field);
-		}
-
-		/**
-		 * Gets the short value at the specified position of a short array.
-		 * @param field Offset of the short array.
-		 * @param index Index of the short in the array.
-		 * @return Short value.
-		 */
-		protected final short getShort(int field, int index)
-		{
-			assert validType(field, index, MPI.SHORT) : typeMismatch;
-			return buffer.getShort(offset + field + index * 2);
-		}
-
-		/**
-		 * Puts a short value in a field.
-		 * @param field Offset of the field.
-		 * @param v     Short value.
-		 */
-		protected final void putShort(int field, short v)
-		{
-			assert validType(field, 0, MPI.SHORT) : typeMismatch;
-			buffer.putShort(offset + field, v);
-		}
-
-		/**
-		 * Puts a short value at the specified position of a short array.
-		 * @param field Offset of the short array.
-		 * @param index Index of the short in the array.
-		 * @param v     Short value.
-		 */
-		protected final void putShort(int field, int index, short v)
-		{
-			assert validType(field, index, MPI.SHORT) : typeMismatch;
-			buffer.putShort(offset + field + index * 2, v);
-		}
-
-		/**
-		 * Gets the int value of a field.
-		 * @param field Offset of the field.
-		 * @return Int value.
-		 */
-		protected final int getInt(int field)
-		{
-			assert validType(field, 0, MPI.INT) : typeMismatch;
-			return buffer.getInt(offset + field);
-		}
-
-		/**
-		 * Gets the int value at the specified position of an int array.
-		 * @param field Offset of the int array.
-		 * @param index Index of the int in the array.
-		 * @return Int value.
-		 */
-		protected final int getInt(int field, int index)
-		{
-			assert validType(field, index, MPI.INT) : typeMismatch;
-			return buffer.getInt(offset + field + index * 4);
-		}
-
-		/**
-		 * Puts an int value in a field.
-		 * @param field Offset of the field.
-		 * @param v     Int value.
-		 */
-		protected final void putInt(int field, int v)
-		{
-			assert validType(field, 0, MPI.INT) : typeMismatch;
-			buffer.putInt(offset + field, v);
-		}
-
-		/**
-		 * Puts an int value at the specified position of an int array.
-		 * @param field Offset of the int array.
-		 * @param index Index of the int in the array.
-		 * @param v     Int value.
-		 */
-		protected final void putInt(int field, int index, int v)
-		{
-			assert validType(field, index, MPI.INT) : typeMismatch;
-			buffer.putInt(offset + field + index * 4, v);
-		}
-
-		/**
-		 * Gets the long value of a field.
-		 * @param field Offset of the field.
-		 * @return Long value.
-		 */
-		protected final long getLong(int field)
-		{
-			assert validType(field, 0, MPI.LONG) : typeMismatch;
-			return buffer.getLong(offset + field);
-		}
-
-		/**
-		 * Gets the long value at the specified position of a long array.
-		 * @param field Offset of the long array.
-		 * @param index Index of the long in the array.
-		 * @return Long value.
-		 */
-		protected final long getLong(int field, int index)
-		{
-			assert validType(field, index, MPI.LONG) : typeMismatch;
-			return buffer.getLong(offset + field + index * 8);
-		}
-
-		/**
-		 * Puts a long value in a field.
-		 * @param field Offset of the field.
-		 * @param v     Long value.
-		 */
-		protected final void putLong(int field, long v)
-		{
-			assert validType(field, 0, MPI.LONG) : typeMismatch;
-			buffer.putLong(offset + field, v);
-		}
-
-		/**
-		 * Puts a long value at the specified position of a long array.
-		 * @param field Offset of the long array.
-		 * @param index Index of the long in the array.
-		 * @param v     Long value.
-		 */
-		protected final void putLong(int field, int index, long v)
-		{
-			assert validType(field, index, MPI.LONG) : typeMismatch;
-			buffer.putLong(offset + field + index * 8, v);
-		}
-
-		/**
-		 * Gets the float value of a field.
-		 * @param field Offset of the field.
-		 * @return Float value.
-		 */
-		protected final float getFloat(int field)
-		{
-			assert validType(field, 0, MPI.FLOAT) : typeMismatch;
-			return buffer.getFloat(offset + field);
-		}
-
-		/**
-		 * Gets the float value at the specified position of a float array.
-		 * @param field Offset of the float array.
-		 * @param index Index of the float in the array.
-		 * @return Float value.
-		 */
-		protected final float getFloat(int field, int index)
-		{
-			assert validType(field, index, MPI.FLOAT) : typeMismatch;
-			return buffer.getFloat(offset + field + index * 4);
-		}
-
-		/**
-		 * Puts a float value in a field.
-		 * @param field Offset of the field.
-		 * @param v     Float value.
-		 */
-		protected final void putFloat(int field, float v)
-		{
-			assert validType(field, 0, MPI.FLOAT) : typeMismatch;
-			buffer.putFloat(offset + field, v);
-		}
-
-		/**
-		 * Puts a float value at the specified position of a float array.
-		 * @param field Offset of the float array.
-		 * @param index Index of the float in the array.
-		 * @param v     Float value.
-		 */
-		protected final void putFloat(int field, int index, float v)
-		{
-			assert validType(field, index, MPI.FLOAT) : typeMismatch;
-			buffer.putFloat(offset + field + index * 4, v);
-		}
-
-		/**
-		 * Gets the double value of a field.
-		 * @param field Offset of the field.
-		 * @return Double value.
-		 */
-		protected final double getDouble(int field)
-		{
-			assert validType(field, 0, MPI.DOUBLE) : typeMismatch;
-			return buffer.getDouble(offset + field);
-		}
-
-		/**
-		 * Gets the double value at the specified position of a double array.
-		 * @param field Offset of the double array.
-		 * @param index Index of the double in the array.
-		 * @return Double value.
-		 */
-		protected final double getDouble(int field, int index)
-		{
-			assert validType(field, index, MPI.DOUBLE) : typeMismatch;
-			return buffer.getDouble(offset + field + index * 8);
-		}
-
-		/**
-		 * Puts a double value in a field.
-		 * @param field Offset of the field.
-		 * @param v     Double value.
-		 */
-		protected final void putDouble(int field, double v)
-		{
-			assert validType(field, 0, MPI.DOUBLE) : typeMismatch;
-			buffer.putDouble(offset + field, v);
-		}
-
-		/**
-		 * Puts a double value at the specified position of a double array.
-		 * @param field Offset of the double array.
-		 * @param index Index of the double in the array.
-		 * @param v     Double value.
-		 */
-		protected final void putDouble(int field, int index, double v)
-		{
-			assert validType(field, index, MPI.DOUBLE) : typeMismatch;
-			buffer.putDouble(offset + field + index * 8, v);
-		}
-
-		@SuppressWarnings("javadoc")
-		/**
-		 * Gets the struct data of a field.
-		 * @param struct Struct type.
-		 * @param field  Offset of the field.
-		 * @return Struct data.
-		 */
-		protected final <S extends Struct, D extends Struct.Data>
-		D getData(S struct, int field)
-		{
-			Struct s = (Struct)struct;
-			assert validType(field, 0, s.datatype) : typeMismatch;
-			return s.newData(buffer, offset + field);
-		}
-
-		@SuppressWarnings("javadoc")
-		/**
-		 * Gets the struct data at the specified position of a struct array.
-		 * @param struct Struct type.
-		 * @param field  Offset of the struct array.
-		 * @param index  Index of the struct in the array.
-		 * @return Struct data.
-		 */
-		protected final <S extends Struct, D extends Struct.Data>
-		D getData(S struct, int field, int index)
-		{
-			Struct s = (Struct)struct;
-			assert validType(field, index, s.datatype) : typeMismatch;
-			return s.newData(buffer, offset + field + index * s.extent);
-		}
-
-		/**
-		 * Gets the buffer of a field.
-		 * <p>The buffer can be used in {@code send}/{@code recv} operations.
-		 * @param type  Data type of the buffer.
-		 * @param field Offset of the field.
-		 * @return Buffer object.
-		 */
-		protected final ByteBuffer getBuffer(Datatype type, int field)
-		{
-			assert validType(field, 0, type) : typeMismatch;
-			int position = offset + field;
-			return position == 0 ? buffer : MPI.slice(buffer, position);
-		}
-
-		/**
-		 * Gets the buffer data at the specified position of a buffer array.
-		 * <p>The buffer can be used in {@code send}/{@code recv} operations.
-		 * @param type  Data type of the buffer.
-		 * @param field Offset of the buffer array.
-		 * @param index Index of the buffer in the array.
-		 * @return Buffer object.
-		 * @throws MPIException Signals that an MPI error of some sort has occurred.
-		 */
-		protected final ByteBuffer getBuffer(Datatype type, int field, int index)
-				throws MPIException
-		{
-			assert validType(field, index, type) : typeMismatch;
-
-			int extent   = type.getExtent() * type.baseSize,
-					position = offset + field + index * extent;
-
-			return position == 0 ? buffer : MPI.slice(buffer, position);
-		}
-
-	} // Data
-
-} // Struct
diff --git a/ompi/mpi/java/java/UserFunction.java b/ompi/mpi/java/java/UserFunction.java
deleted file mode 100644
index 2618b8b2040..00000000000
--- a/ompi/mpi/java/java/UserFunction.java
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-/*
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- */
-/*
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-       https://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
- */
-/*
- * File         : User_function.java
- * Author       : Xinying Li
- * Created      : Thu Apr  9 12:22:15 1998
- * Revision     : $Revision: 1.4 $
- * Updated      : $Date: 1999/09/13 16:14:30 $
- * Copyright: Northeast Parallel Architectures Center
- *            at Syracuse University 1998
- */
-
-package mpi;
-
-import java.nio.*;
-
-/**
- * Java equivalent of the {@code MPI_USER_FUNCTION}.
- */
-public abstract class UserFunction
-{
-	/**
-	 * User-defined function for a new {@code Op}.
-	 * @param inVec    		array of values to combine with {@code inoutvec} elements
-	 * @param inOutVec 		in-out array of accumulator locations
-	 * @param count    		number of items in arrays
-	 * @param datatype 		type of each item
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void call(Object inVec, Object inOutVec, int count, Datatype datatype)
-			throws MPIException
-	{
-		throw new UnsupportedOperationException("Not supported yet.");
-	}
-
-	/**
-	 * User-defined function for a new {@code Op}.
-	 * @param in       		direct byte buffer to combine with {@code inOut} buffer
-	 * @param inOut   		in-out direct byte buffer of accumulator locations
-	 * @param count    		number of items in buffers
-	 * @param datatype 		type of each item
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void call(ByteBuffer in, ByteBuffer inOut, int count, Datatype datatype)
-			throws MPIException
-	{
-		switch(datatype.baseType)
-		{
-		case Datatype.BYTE:
-			vCall(in, inOut, count, datatype);
-			break;
-		case Datatype.CHAR:
-			vCall(in.asCharBuffer(), inOut.asCharBuffer(), count, datatype);
-			break;
-		case Datatype.SHORT:
-			vCall(in.asShortBuffer(), inOut.asShortBuffer(), count, datatype);
-			break;
-		case Datatype.INT:
-			vCall(in.asIntBuffer(), inOut.asIntBuffer(), count, datatype);
-			break;
-		case Datatype.LONG:
-			vCall(in.asLongBuffer(), inOut.asLongBuffer(), count, datatype);
-			break;
-		case Datatype.FLOAT:
-			vCall(in.asFloatBuffer(), inOut.asFloatBuffer(), count, datatype);
-			break;
-		case Datatype.DOUBLE:
-			vCall(in.asDoubleBuffer(), inOut.asDoubleBuffer(), count, datatype);
-			break;
-		case Datatype.PACKED:
-			vCall(in, inOut, count, datatype);
-			break;
-		default:
-			throw new IllegalArgumentException("Unsupported datatype.");
-		}
-	}
-
-	private void vCall(ByteBuffer in, ByteBuffer inOut,
-			int count, Datatype datatype) throws MPIException
-	{
-		int    extent   = datatype.getExtent();
-		byte[] inVec    = new byte[count * extent],
-				inOutVec = new byte[count * extent];
-
-		in.get(inVec);
-		inOut.get(inOutVec);
-		call(inVec, inOutVec, count, datatype);
-		inOut.clear();
-		inOut.put(inOutVec);
-	}
-
-	private void vCall(CharBuffer inBuf, CharBuffer inOutBuf,
-			int count, Datatype datatype) throws MPIException
-	{
-		int    extent   = datatype.getExtent();
-		char[] inVec    = new char[count * extent],
-				inOutVec = new char[count * extent];
-
-		inBuf.get(inVec);
-		inOutBuf.get(inOutVec);
-		call(inVec, inOutVec, count, datatype);
-		inOutBuf.clear();
-		inOutBuf.put(inOutVec);
-	}
-
-	private void vCall(ShortBuffer inBuf, ShortBuffer inOutBuf,
-			int count, Datatype datatype) throws MPIException
-	{
-		int     extent   = datatype.getExtent();
-		short[] inVec    = new short[count * extent],
-				inOutVec = new short[count * extent];
-
-		inBuf.get(inVec);
-		inOutBuf.get(inOutVec);
-		call(inVec, inOutVec, count, datatype);
-		inOutBuf.clear();
-		inOutBuf.put(inOutVec);
-	}
-
-	private void vCall(IntBuffer inBuf, IntBuffer inOutBuf,
-			int count, Datatype datatype) throws MPIException
-	{
-		int   extent   = datatype.getExtent();
-		int[] inVec    = new int[count * extent],
-				inOutVec = new int[count * extent];
-
-		inBuf.get(inVec);
-		inOutBuf.get(inOutVec);
-		call(inVec, inOutVec, count, datatype);
-		inOutBuf.clear();
-		inOutBuf.put(inOutVec);
-	}
-
-	private void vCall(LongBuffer inBuf, LongBuffer inOutBuf,
-			int count, Datatype datatype) throws MPIException
-	{
-		int    extent   = datatype.getExtent();
-		long[] inVec    = new long[count * extent],
-				inOutVec = new long[count * extent];
-
-		inBuf.get(inVec);
-		inOutBuf.get(inOutVec);
-		call(inVec, inOutVec, count, datatype);
-		inOutBuf.clear();
-		inOutBuf.put(inOutVec);
-	}
-
-	private void vCall(FloatBuffer inBuf, FloatBuffer inOutBuf,
-			int count, Datatype datatype) throws MPIException
-	{
-		int     extent   = datatype.getExtent();
-		float[] inVec    = new float[count * extent],
-				inOutVec = new float[count * extent];
-
-		inBuf.get(inVec);
-		inOutBuf.get(inOutVec);
-		call(inVec, inOutVec, count, datatype);
-		inOutBuf.clear();
-		inOutBuf.put(inOutVec);
-	}
-
-	private void vCall(DoubleBuffer inBuf, DoubleBuffer inOutBuf,
-			int count, Datatype datatype) throws MPIException
-	{
-		int      extent   = datatype.getExtent();
-		double[] inVec    = new double[count * extent],
-				inOutVec = new double[count * extent];
-
-		inBuf.get(inVec);
-		inOutBuf.get(inOutVec);
-		call(inVec, inOutVec, count, datatype);
-		inOutBuf.clear();
-		inOutBuf.put(inOutVec);
-	}
-
-} // UserFunction
diff --git a/ompi/mpi/java/java/Version.java b/ompi/mpi/java/java/Version.java
deleted file mode 100644
index 2194ce35a54..00000000000
--- a/ompi/mpi/java/java/Version.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2022      Cisco Systems, Inc.  All rights reserved
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- *
- * This file is almost a complete re-write for Open MPI compared to the
- * original mpiJava package. Its license and copyright are listed below.
- * See <path to ompi/mpi/java/README> for more information.
- *
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- *
- * File         : Version.java
- * Author       : Nathaniel Graham
- * Created      : Thu Jul  23 09:25 2015
- */
-
-package mpi;
-
-/**
- * Version and Subversion for MPI
- */
-public final class Version
-{
-private final int version;
-private final int subVersion;
-
-protected Version(int version, int subVersion)
-{
-    this.version = version;
-    this.subVersion = subVersion;
-}
-
-/**
- * Gets the MPI version.
- * @return MPI version
- */
-public int getVersion()
-{
-    return version;
-}
-
-/**
- * Gets the MPI subversion.
- * @return MPI subversion
- */
-public int getSubVersion()
-{
-    return subVersion;
-}
-
-} // Version
diff --git a/ompi/mpi/java/java/Win.java b/ompi/mpi/java/java/Win.java
deleted file mode 100644
index e9102f36c91..00000000000
--- a/ompi/mpi/java/java/Win.java
+++ /dev/null
@@ -1,921 +0,0 @@
-/*
- * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * Copyright (c) 2015      Research Organization for Information Science
- *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2015      Los Alamos National Security, LLC. All rights
- *                         reserved.
- * Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- */
-
-package mpi;
-
-import java.nio.*;
-
-/**
- * This class represents {@code MPI_Win}.
- */
-public final class Win implements Freeable
-{
-	private long handle;
-	public static final int WIN_NULL = 0;
-	public static final int FLAVOR_PRIVATE = 0;
-	public static final int FLAVOR_SHARED = 1;
-
-	/**
-	 * Java binding of {@code MPI_WIN_CREATE}.
-	 * @param base     initial address of window
-	 * @param size     size of window (buffer elements)
-	 * @param dispUnit local unit size for displacements (buffer elements)
-	 * @param info     info object
-	 * @param comm     communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Win(Buffer base, int size, int dispUnit, Info info, Comm comm)
-			throws MPIException
-	{
-		if(!base.isDirect())
-			throw new IllegalArgumentException("The buffer must be direct.");
-
-		int baseSize;
-
-		if(base instanceof ByteBuffer)
-			baseSize = 1;
-		else if(base instanceof CharBuffer || base instanceof ShortBuffer)
-			baseSize = 2;
-		else if(base instanceof IntBuffer || base instanceof FloatBuffer)
-			baseSize = 4;
-		else if(base instanceof LongBuffer || base instanceof DoubleBuffer)
-			baseSize = 8;
-		else
-			throw new AssertionError();
-
-		int sizeBytes = size * baseSize,
-				dispBytes = dispUnit * baseSize;
-
-		handle = createWin(base, sizeBytes, dispBytes, info.handle, comm.handle);
-	}
-
-	private native long createWin(
-			Buffer base, int size, int dispUnit, long info, long comm)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_WIN_ALLOCATE} and {@code MPI_WIN_ALLOCATE_SHARED}.
-	 * @param size     size of window (buffer elements)
-	 * @param dispUnit 	local unit size for displacements (buffer elements)
-	 * @param info     	info object
-	 * @param comm     	communicator
-	 * @param base     	initial address of window
-	 * @param flavor	FLAVOR_PRIVATE or FLAVOR_SHARED
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Win(int size, int dispUnit, Info info, Comm comm, Buffer base, int flavor)
-			throws MPIException
-	{
-		if(!base.isDirect())
-			throw new IllegalArgumentException("The buffer must be direct.");
-
-		int baseSize;
-
-		if(base instanceof ByteBuffer)
-			baseSize = 1;
-		else if(base instanceof CharBuffer || base instanceof ShortBuffer)
-			baseSize = 2;
-		else if(base instanceof IntBuffer || base instanceof FloatBuffer)
-			baseSize = 4;
-		else if(base instanceof LongBuffer || base instanceof DoubleBuffer)
-			baseSize = 8;
-		else
-			throw new AssertionError();
-
-		int sizeBytes = size * baseSize,
-				dispBytes = dispUnit * baseSize;
-
-		if(flavor == 0) {
-			handle = allocateWin(sizeBytes, dispBytes, info.handle, comm.handle, base);
-		} else if(flavor == 1) {
-			handle = allocateSharedWin(sizeBytes, dispBytes, info.handle, comm.handle, base);
-		}
-	}
-
-	private native long allocateWin(
-			int size, int dispUnit, long info, long comm, Buffer base)
-					throws MPIException;
-
-	private native long allocateSharedWin(
-			int size, int dispUnit, long info, long comm, Buffer base)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_WIN_CREATE_DYNAMIC}.
-	 * @param info     info object
-	 * @param comm     communicator
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Win(Info info, Comm comm)
-			throws MPIException
-	{
-		handle = createDynamicWin(info.handle, comm.handle);
-	}
-
-	private native long createDynamicWin(
-			long info, long comm)
-					throws MPIException;
-
-	private int getBaseType(Datatype orgType, Datatype targetType)
-	{
-		int baseType = orgType.baseType;
-
-		if(baseType != targetType.baseType)
-		{
-			throw new IllegalArgumentException(
-					"Both datatype arguments must be constructed "+
-					"from the same predefined datatype.");
-		}
-
-		return baseType;
-	}
-
-	/**
-	 * Java binding of {@code MPI_WIN_ATTACH}.
-	 * @param base     initial address of window
-	 * @param size     size of window (buffer elements)
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void attach(Buffer base, int size) throws MPIException
-	{
-		MPI.check();
-		if(!base.isDirect())
-			throw new IllegalArgumentException("The buffer must be direct.");
-
-		int baseSize;
-
-		if(base instanceof ByteBuffer)
-			baseSize = 1;
-		else if(base instanceof CharBuffer || base instanceof ShortBuffer)
-			baseSize = 2;
-		else if(base instanceof IntBuffer || base instanceof FloatBuffer)
-			baseSize = 4;
-		else if(base instanceof LongBuffer || base instanceof DoubleBuffer)
-			baseSize = 8;
-		else
-			throw new AssertionError();
-
-		int sizeBytes = size * baseSize;
-
-		attach(handle, base, sizeBytes);
-	}
-
-	private native void attach(long win, Buffer base, int size) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_WIN_DETACH}.
-	 * @param base     initial address of window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void detach(Buffer base) throws MPIException
-	{
-		MPI.check();
-		if(!base.isDirect())
-			throw new IllegalArgumentException("The buffer must be direct.");
-
-		detach(handle, base);
-	}
-
-	private native void detach(long win, Buffer base) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_GET_GROUP}.
-	 * @return group of processes which share access to the window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Group getGroup() throws MPIException
-	{
-		MPI.check();
-		return new Group(getGroup(handle));
-	}
-
-	private native long getGroup(long win) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_PUT}.
-	 * @param origin      origin buffer
-	 * @param orgCount    number of entries in origin buffer
-	 * @param orgType     datatype of each entry in origin buffer
-	 * @param targetRank  rank of target
-	 * @param targetDisp  displacement from start of window to target buffer
-	 * @param targetCount number of entries in target buffer
-	 * @param targetType  datatype of each entry in target buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void put(Buffer origin, int orgCount, Datatype orgType,
-			int targetRank, int targetDisp, int targetCount,
-			Datatype targetType)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-
-		put(handle, origin, orgCount, orgType.handle,
-				targetRank, targetDisp, targetCount, targetType.handle,
-				getBaseType(orgType, targetType));
-	}
-
-	private native void put(
-			long win, Buffer origin, int orgCount, long orgType,
-			int targetRank, int targetDisp, int targetCount, long targetType,
-			int baseType) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_GET}.
-	 * @param origin      origin buffer
-	 * @param orgCount    number of entries in origin buffer
-	 * @param orgType     datatype of each entry in origin buffer
-	 * @param targetRank  rank of target
-	 * @param targetDisp  displacement from start of window to target buffer
-	 * @param targetCount number of entries in target buffer
-	 * @param targetType  datatype of each entry in target buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void get(Buffer origin, int orgCount, Datatype orgType,
-			int targetRank, int targetDisp, int targetCount,
-			Datatype targetType)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-
-		get(handle, origin, orgCount, orgType.handle,
-				targetRank, targetDisp, targetCount, targetType.handle,
-				getBaseType(orgType, targetType));
-	}
-
-	private native void get(
-			long win, Buffer origin, int orgCount, long orgType,
-			int targetRank, int targetDisp, int targetCount, long targetType,
-			int baseType) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_ACCUMULATE}.
-	 * @param origin      origin buffer
-	 * @param orgCount    number of entries in origin buffer
-	 * @param orgType     datatype of each entry in origin buffer
-	 * @param targetRank  rank of target
-	 * @param targetDisp  displacement from start of window to target buffer
-	 * @param targetCount number of entries in target buffer
-	 * @param targetType  datatype of each entry in target buffer
-	 * @param op          reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void accumulate(Buffer origin, int orgCount, Datatype orgType,
-			int targetRank, int targetDisp, int targetCount,
-			Datatype targetType, Op op)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-
-		accumulate(handle, origin, orgCount, orgType.handle,
-				targetRank, targetDisp, targetCount, targetType.handle,
-				op, op.handle, getBaseType(orgType, targetType));
-	}
-
-	private native void accumulate(
-			long win, Buffer origin, int orgCount, long orgType,
-			int targetRank, int targetDisp, int targetCount, long targetType,
-			Op jOp, long hOp, int baseType) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_WIN_FENCE}.
-	 * @param assertion program assertion
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void fence(int assertion) throws MPIException
-	{
-		MPI.check();
-		fence(handle, assertion);
-	}
-
-	private native void fence(long win, int assertion) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_START}.
-	 * @param group     group of target processes
-	 * @param assertion program assertion
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void start(Group group, int assertion) throws MPIException
-	{
-		MPI.check();
-		start(handle, group.handle, assertion);
-	}
-
-	private native void start(long win, long group, int assertion)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_COMPLETE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void complete() throws MPIException
-	{
-		MPI.check();
-		complete(handle);
-	}
-
-	private native void complete(long win) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_POST}.
-	 * @param group     group of origin processes
-	 * @param assertion program assertion
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void post(Group group, int assertion) throws MPIException
-	{
-		MPI.check();
-		post(handle, group.handle, assertion);
-	}
-
-	private native void post(long win, long group, int assertion)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_WAIT}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void waitFor() throws MPIException
-	{
-		MPI.check();
-		waitFor(handle);
-	}
-
-	private native void waitFor(long win) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_TEST}.
-	 * @return true if success
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public boolean test() throws MPIException
-	{
-		MPI.check();
-		return test(handle);
-	}
-
-	private native boolean test(long win) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_LOCK}.
-	 * @param lockType  either MPI.LOCK_EXCLUSIVE or MPI.LOCK_SHARED
-	 * @param rank      rank of locked window
-	 * @param assertion program assertion
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void lock(int lockType, int rank, int assertion) throws MPIException
-	{
-		MPI.check();
-		lock(handle, lockType, rank, assertion);
-	}
-
-	private native void lock(long win, int lockType, int rank, int assertion)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_UNLOCK}.
-	 * @param rank rank of window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void unlock(int rank) throws MPIException
-	{
-		MPI.check();
-		unlock(handle, rank);
-	}
-
-	private native void unlock(long win, int rank) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_SET_ERRHANDLER}.
-	 * @param errhandler new MPI error handler for window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setErrhandler(Errhandler errhandler) throws MPIException
-	{
-		MPI.check();
-		setErrhandler(handle, errhandler.handle);
-	}
-
-	private native void setErrhandler(long win, long errhandler)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_GET_ERRHANDLER}.
-	 * @return MPI error handler currently associated with window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Errhandler getErrhandler() throws MPIException
-	{
-		MPI.check();
-		return new Errhandler(getErrhandler(handle));
-	}
-
-	private native long getErrhandler(long win);
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_CALL_ERRHANDLER}.
-	 * @param errorCode error code
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void callErrhandler(int errorCode) throws MPIException
-	{
-		callErrhandler(handle, errorCode);
-	}
-
-	private native void callErrhandler(long handle, int errorCode)
-			throws MPIException;
-
-	/**
-	 * Create a new attribute key.
-	 * <p>Java binding of the MPI operation {@code MPI_WIN_CREATE_KEYVAL}.
-	 * @return attribute key for future access
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static int createKeyval() throws MPIException
-	{
-		MPI.check();
-		return createKeyval_jni();
-	}
-
-	private static native int createKeyval_jni() throws MPIException;
-
-	/**
-	 * Frees an attribute key.
-	 * <p>Java binding of the MPI operation {@code MPI_WIN_FREE_KEYVAL}.
-	 * @param keyval attribute key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public static void freeKeyval(int keyval) throws MPIException
-	{
-		MPI.check();
-		freeKeyval_jni(keyval);
-	}
-
-	private static native void freeKeyval_jni(int keyval) throws MPIException;
-
-	/**
-	 * Stores attribute value associated with a key.
-	 * <p>Java binding of the MPI operation {@code MPI_WIN_SET_ATTR}.
-	 * @param keyval attribute key
-	 * @param value  attribute value
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setAttr(int keyval, Object value) throws MPIException
-	{
-		MPI.check();
-		setAttr(handle, keyval, MPI.attrSet(value));
-	}
-
-	private native void setAttr(long win, int keyval, byte[] value)
-			throws MPIException;
-
-	/**
-	 * Retrieves attribute value by key.
-	 * <p>Java binding of the MPI operation {@code MPI_WIN_GET_ATTR}.
-	 * @param keyval attribute key
-	 * @return attribute value or null if no attribute is associated with the key.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Object getAttr(int keyval) throws MPIException
-	{
-		MPI.check();
-		Object obj = getAttr(handle, keyval);
-		return obj instanceof byte[] ? MPI.attrGet((byte[])obj) : obj;
-	}
-
-	private native Object getAttr(long win, int keyval) throws MPIException;
-
-	/**
-	 * Deletes an attribute value associated with a key.
-	 * <p>Java binding of the MPI operation {@code MPI_WIN_DELETE_ATTR}.
-	 * @param keyval attribute key
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void deleteAttr(int keyval) throws MPIException
-	{
-		MPI.check();
-		deleteAttr(handle, keyval);
-	}
-
-	private native void deleteAttr(long win, int keyval) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_WIN_FREE}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	@Override public void free() throws MPIException
-	{
-		MPI.check();
-		handle = free(handle);
-	}
-
-	private native long free(long win) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_GET_INFO}.
-	 * @return Info	Info object associated with this window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Info getInfo() throws MPIException
-	{
-		MPI.check();
-		return new Info(getInfo(handle));
-	}
-
-	private native long getInfo(long win)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_SET_INFO}.
-	 * @param info the new info
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setInfo(Info info) throws MPIException
-	{
-		MPI.check();
-		setInfo(handle, info.handle);
-	}
-
-	private native void setInfo(long win, long info)
-			throws MPIException;
-
-	/**
-	 * <p>Java binding of the MPI operation {@code MPI_RPUT}.
-	 * @param origin_addr   	initial address of origin buffer
-	 * @param origin_count 		number of entries in origin buffer
-	 * @param origin_datatype  	datatype of each entry in origin buffer
-	 * @param target_rank		rank of target
-	 * @param target_disp		displacement from start of window to target buffer
-	 * @param target_count		number of entries in target buffer
-	 * @param target_datatype	datatype of each entry in target buffer
-	 * @return RMA request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request rPut(Buffer origin_addr, int origin_count,
-			Datatype origin_datatype, int target_rank, int target_disp,
-			int target_count, Datatype target_datatype)
-					throws MPIException
-	{
-		if(!origin_addr.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-		Request req = new Request(rPut(handle, origin_addr, origin_count,
-				origin_datatype.handle, target_rank, target_disp,
-				target_count, target_datatype.handle, getBaseType(origin_datatype, target_datatype)));
-		req.addSendBufRef(origin_addr);
-		return req;
-	}
-
-	private native long rPut(long win, Buffer origin_addr, int origin_count,
-			long origin_datatype, int target_rank, int target_disp,
-			int target_count, long target_datatype, int baseType)
-					throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_RGET}.
-	 * @param origin      	origin buffer
-	 * @param orgCount    	number of entries in origin buffer
-	 * @param orgType     	datatype of each entry in origin buffer
-	 * @param targetRank  	rank of target
-	 * @param targetDisp  	displacement from start of window to target buffer
-	 * @param targetCount 	number of entries in target buffer
-	 * @param targetType  	datatype of each entry in target buffer
-	 * @return RMA request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public final Request rGet(Buffer origin, int orgCount, Datatype orgType,
-			int targetRank, int targetDisp, int targetCount,
-			Datatype targetType)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-		Request req = new Request(rGet(handle, origin, orgCount, orgType.handle,
-				targetRank, targetDisp, targetCount, targetType.handle,
-				getBaseType(orgType, targetType)));
-		req.addRecvBufRef(origin);
-		return req;
-	}
-
-	private native long rGet(
-			long win, Buffer origin, int orgCount, long orgType,
-			int targetRank, int targetDisp, int targetCount, long targetType,
-			int baseType) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_RACCUMULATE}.
-	 * @param origin      origin buffer
-	 * @param orgCount    number of entries in origin buffer
-	 * @param orgType     datatype of each entry in origin buffer
-	 * @param targetRank  rank of target
-	 * @param targetDisp  displacement from start of window to target buffer
-	 * @param targetCount number of entries in target buffer
-	 * @param targetType  datatype of each entry in target buffer
-	 * @param op          reduce operation
-	 * @return RMA request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public Request rAccumulate(Buffer origin, int orgCount, Datatype orgType,
-			int targetRank, int targetDisp, int targetCount,
-			Datatype targetType, Op op)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-		Request req = new Request(rAccumulate(handle, origin, orgCount, orgType.handle,
-				targetRank, targetDisp, targetCount, targetType.handle,
-				op, op.handle, getBaseType(orgType, targetType)));
-		req.addSendBufRef(origin);
-		return req;
-	}
-
-	private native long rAccumulate(
-			long win, Buffer origin, int orgCount, long orgType,
-			int targetRank, int targetDisp, int targetCount, long targetType,
-			Op jOp, long hOp, int baseType) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_GET_ACCUMULATE}.
-	 * @param origin      	origin buffer
-	 * @param orgCount    	number of entries in origin buffer
-	 * @param orgType		datatype of each entry in origin buffer
-	 * @param resultAddr   	result buffer
-	 * @param resultCount	number of entries in result buffer
-	 * @param resultType   	datatype of each entry in result buffer
-	 * @param targetRank  	rank of target
-	 * @param targetDisp  	displacement from start of window to target buffer
-	 * @param targetCount 	number of entries in target buffer
-	 * @param targetType  	datatype of each entry in target buffer
-	 * @param op          	reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-
-	public void getAccumulate(Buffer origin, int orgCount, Datatype orgType,
-			Buffer resultAddr, int resultCount, Datatype resultType,
-			int targetRank, int targetDisp, int targetCount,
-			Datatype targetType, Op op)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-
-		getAccumulate(handle, origin, orgCount, orgType.handle,
-				resultAddr, resultCount, resultType.handle,
-				targetRank, targetDisp, targetCount, targetType.handle,
-				op, op.handle, getBaseType(orgType, targetType));
-	}
-
-	private native void getAccumulate(
-			long win, Buffer origin, int orgCount, long orgType,
-			Buffer resultAddr, int resultCount, long resultType,
-			int targetRank, int targetDisp, int targetCount, long targetType,
-			Op jOp, long hOp, int baseType) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_RGET_ACCUMULATE}.
-	 * @param origin      	origin buffer
-	 * @param orgCount    	number of entries in origin buffer
-	 * @param orgType		datatype of each entry in origin buffer
-	 * @param resultAddr   	result buffer
-	 * @param resultCount	number of entries in result buffer
-	 * @param resultType   	datatype of each entry in result buffer
-	 * @param targetRank  	rank of target
-	 * @param targetDisp  	displacement from start of window to target buffer
-	 * @param targetCount 	number of entries in target buffer
-	 * @param targetType  	datatype of each entry in target buffer
-	 * @param op          	reduce operation
-	 * @return RMA request
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-
-	public Request rGetAccumulate(Buffer origin, int orgCount, Datatype orgType,
-			Buffer resultAddr, int resultCount, Datatype resultType,
-			int targetRank, int targetDisp, int targetCount,
-			Datatype targetType, Op op)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-		Request req = new Request(rGetAccumulate(handle, origin, orgCount, orgType.handle,
-				resultAddr, resultCount, resultType.handle,
-				targetRank, targetDisp, targetCount, targetType.handle,
-				op, op.handle, getBaseType(orgType, targetType)));
-		req.addRecvBufRef(origin);
-		return req;
-	}
-
-	private native long rGetAccumulate(
-			long win, Buffer origin, int orgCount, long orgType,
-			Buffer resultAddr, int resultCount, long resultType,
-			int targetRank, int targetDisp, int targetCount, long targetType,
-			Op jOp, long hOp, int baseType) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_LOCK_ALL}.
-	 * @param assertion program assertion
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void lockAll(int assertion) throws MPIException
-	{
-		MPI.check();
-		lockAll(handle, assertion);
-	}
-
-	private native void lockAll(long win, int assertion)
-			throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_UNLOCK_ALL}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void unlockAll() throws MPIException
-	{
-		MPI.check();
-		unlockAll(handle);
-	}
-
-	private native void unlockAll(long win) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_SYNC}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void sync() throws MPIException
-	{
-		MPI.check();
-		sync(handle);
-	}
-
-	private native void sync(long win) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_FLUSH}.
-	 * @param targetRank	rank of target window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void flush(int targetRank) throws MPIException
-	{
-		MPI.check();
-		flush(handle, targetRank);
-	}
-
-	private native void flush(long win, int targetRank) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_FLUSH_ALL}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void flushAll() throws MPIException
-	{
-		MPI.check();
-		flushAll(handle);
-	}
-
-	private native void flushAll(long win) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_COMPARE_AND_SWAP}.
-	 * @param origin      	origin buffer
-	 * @param compareAddr   compare buffer
-	 * @param resultAddr   	result buffer
-	 * @param targetType  	datatype of each entry in target buffer
-	 * @param targetRank  	rank of target
-	 * @param targetDisp  	displacement from start of window to target buffer
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-
-	public void compareAndSwap(Buffer origin, Buffer compareAddr, Buffer resultAddr,
-			Datatype targetType, int targetRank, int targetDisp)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-
-		compareAndSwap(handle, origin, compareAddr, resultAddr,
-				targetType.handle, targetRank, targetDisp);
-	}
-
-	private native void compareAndSwap(
-			long win, Buffer origin, Buffer compareAddr, Buffer resultAddr,
-			long targetType, int targetRank, int targetDisp) throws MPIException;
-
-	/**
-	 * Java binding of {@code MPI_FETCH_AND_OP}.
-	 * @param origin      	origin buffer
-	 * @param resultAddr   	result buffer
-	 * @param dataType  	datatype of entry in origin, result, and target buffers
-	 * @param targetRank  	rank of target
-	 * @param targetDisp  	displacement from start of window to target buffer
-	 * @param op          	reduce operation
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-
-	public void fetchAndOp(Buffer origin, Buffer resultAddr, Datatype dataType,
-			int targetRank, int targetDisp, Op op)
-					throws MPIException
-	{
-		MPI.check();
-
-		if(!origin.isDirect())
-			throw new IllegalArgumentException("The origin must be direct buffer.");
-
-		fetchAndOp(handle, origin, resultAddr, dataType.handle, targetRank,
-				targetDisp, op, op.handle, getBaseType(dataType, dataType));
-	}
-
-	private native void fetchAndOp(
-			long win, Buffer origin, Buffer resultAddr, long targetType, int targetRank,
-			int targetDisp, Op jOp, long hOp, int baseType) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_FLUSH_LOCAL}.
-	 * @param targetRank	rank of target window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-
-	public void flushLocal(int targetRank) throws MPIException
-	{
-		MPI.check();
-		flushLocal(handle, targetRank);
-	}
-
-	private native void flushLocal(long win, int targetRank) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_FLUSH_LOCAL_ALL}.
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-
-	public void flushLocalAll() throws MPIException
-	{
-		MPI.check();
-		flushLocalAll(handle);
-	}
-
-	private native void flushLocalAll(long win) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_GET_NAME}.
-	 * @return the name associated with this window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public String getName() throws MPIException
-	{
-		MPI.check();
-		return getName(handle);
-	}
-
-	private native String getName(long handle) throws MPIException;
-
-	/**
-	 * Java binding of the MPI operation {@code MPI_WIN_SET_NAME}.
-	 * @param name	the name to associate with this window
-	 * @throws MPIException Signals that an MPI error of some sort has occurred.
-	 */
-	public void setName(String name) throws MPIException
-	{
-		MPI.check();
-		setName(handle, name);
-	}
-
-	private native void setName(long handle, String name) throws MPIException;
-
-} // Win
diff --git a/ompi/mpi/tool/Makefile.am b/ompi/mpi/tool/Makefile.am
index 72cb71b9b60..8488d41f872 100644
--- a/ompi/mpi/tool/Makefile.am
+++ b/ompi/mpi/tool/Makefile.am
@@ -22,7 +22,7 @@
 # every MPI function twice.  We always build the profiling layer,
 # because the symbols that are always implemented as functions are the
 # PMPI_ namespace symbols.  We sometimes also build the non-profiling
-# layer, if weak symbols can't be used to alias the MPI_ namespace
+# layer, if weak aliases can't be used to alias the MPI_ namespace
 # into the PMPI_ namespace.
 
 noinst_LTLIBRARIES = libmpi_mpit.la libmpi_mpit_profile.la
diff --git a/ompi/mpi/tool/category_changed.c b/ompi/mpi/tool/category_changed.c
index 3b3dce70036..b328163fd56 100644
--- a/ompi/mpi/tool/category_changed.c
+++ b/ompi/mpi/tool/category_changed.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_changed = PMPI_T_category_changed
 #endif
 #define MPI_T_category_changed PMPI_T_category_changed
diff --git a/ompi/mpi/tool/category_get_categories.c b/ompi/mpi/tool/category_get_categories.c
index 813dcc34be1..bf57fdefc0d 100644
--- a/ompi/mpi/tool/category_get_categories.c
+++ b/ompi/mpi/tool/category_get_categories.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_categories = PMPI_T_category_get_categories
 #endif
 #define MPI_T_category_get_categories PMPI_T_category_get_categories
diff --git a/ompi/mpi/tool/category_get_cvars.c b/ompi/mpi/tool/category_get_cvars.c
index bc361f6ba9b..52c280cfb2b 100644
--- a/ompi/mpi/tool/category_get_cvars.c
+++ b/ompi/mpi/tool/category_get_cvars.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_cvars = PMPI_T_category_get_cvars
 #endif
 #define MPI_T_category_get_cvars PMPI_T_category_get_cvars
diff --git a/ompi/mpi/tool/category_get_events.c b/ompi/mpi/tool/category_get_events.c
index 3c6576b79f8..b846941fe6b 100644
--- a/ompi/mpi/tool/category_get_events.c
+++ b/ompi/mpi/tool/category_get_events.c
@@ -11,6 +11,7 @@
  *                         reserved.
  * Copyright (c) 2025      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -23,7 +24,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_events = PMPI_T_category_get_events
 #endif
 #define MPI_T_category_get_events PMPI_T_category_get_events
@@ -31,10 +32,32 @@
 
 int MPI_T_category_get_events(int cat_index, int len, int indices[])
 {
+    const mca_base_var_group_t *group;
     int rc = MPI_SUCCESS;
 
     if (!mpit_is_initialized ()) {
         return MPI_T_ERR_NOT_INITIALIZED;
     }
+
+    ompi_mpit_lock ();
+
+    do {
+        /* Look up the category to validate cat_index, consistent with the
+           sibling MPI_T_category_get_{cvars,pvars,categories} functions. */
+        rc = mca_base_var_group_get (cat_index, &group);
+        if (0 > rc) {
+            rc = (OPAL_ERR_NOT_FOUND == rc) ? MPI_T_ERR_INVALID_INDEX : MPI_T_ERR_INVALID;
+            break;
+        }
+
+        /* Open MPI does not yet register any MPI_T events, so there is
+           nothing to copy into the caller's len-element indices[] array.
+           When events are implemented, populate indices[] from the
+           per-category event list here. */
+        rc = MPI_SUCCESS;
+    } while (0);
+
+    ompi_mpit_unlock ();
+
     return rc;
 }
diff --git a/ompi/mpi/tool/category_get_index.c b/ompi/mpi/tool/category_get_index.c
index 996c5538f35..c766e3af1b3 100644
--- a/ompi/mpi/tool/category_get_index.c
+++ b/ompi/mpi/tool/category_get_index.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_index = PMPI_T_category_get_index
 #endif
 #define MPI_T_category_get_index PMPI_T_category_get_index
diff --git a/ompi/mpi/tool/category_get_info.c b/ompi/mpi/tool/category_get_info.c
index 4906c796125..841c3c7c2f5 100644
--- a/ompi/mpi/tool/category_get_info.c
+++ b/ompi/mpi/tool/category_get_info.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_info = PMPI_T_category_get_info
 #endif
 #define MPI_T_category_get_info PMPI_T_category_get_info
diff --git a/ompi/mpi/tool/category_get_num.c b/ompi/mpi/tool/category_get_num.c
index 4da64da8156..e47574d39e4 100644
--- a/ompi/mpi/tool/category_get_num.c
+++ b/ompi/mpi/tool/category_get_num.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_num = PMPI_T_category_get_num
 #endif
 #define MPI_T_category_get_num PMPI_T_category_get_num
diff --git a/ompi/mpi/tool/category_get_num_events.c b/ompi/mpi/tool/category_get_num_events.c
index b7e49070323..5b765f52e44 100644
--- a/ompi/mpi/tool/category_get_num_events.c
+++ b/ompi/mpi/tool/category_get_num_events.c
@@ -11,6 +11,7 @@
  *                         reserved.
  * Copyright (c) 2025      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -23,7 +24,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_num_events = PMPI_T_category_get_num_events
 #endif
 #define MPI_T_category_get_num_events PMPI_T_category_get_num_events
@@ -31,6 +32,9 @@
 
 int MPI_T_category_get_num_events (int cat_index, int *num_events)
 {
+    const mca_base_var_group_t *group;
+    int rc = MPI_SUCCESS;
+
     if (!mpit_is_initialized ()) {
         return MPI_T_ERR_NOT_INITIALIZED;
     }
@@ -39,7 +43,23 @@ int MPI_T_category_get_num_events (int cat_index, int *num_events)
         return MPI_T_ERR_INVALID;
     }
 
-    *num_events = 0;
+    ompi_mpit_lock ();
+
+    do {
+        /* Look up the category to validate cat_index, consistent with the
+           sibling MPI_T_category_get_events function. */
+        rc = mca_base_var_group_get (cat_index, &group);
+        if (0 > rc) {
+            rc = (OPAL_ERR_NOT_FOUND == rc) ? MPI_T_ERR_INVALID_INDEX : MPI_T_ERR_INVALID;
+            break;
+        }
+
+        /* Open MPI does not yet register any MPI_T events. */
+        *num_events = 0;
+        rc = MPI_SUCCESS;
+    } while (0);
+
+    ompi_mpit_unlock ();
 
-    return MPI_SUCCESS;
+    return rc;
 }
diff --git a/ompi/mpi/tool/category_get_pvars.c b/ompi/mpi/tool/category_get_pvars.c
index c4371762fb5..d939271b256 100644
--- a/ompi/mpi/tool/category_get_pvars.c
+++ b/ompi/mpi/tool/category_get_pvars.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_category_get_pvars = PMPI_T_category_get_pvars
 #endif
 #define MPI_T_category_get_pvars PMPI_T_category_get_pvars
diff --git a/ompi/mpi/tool/cvar_get_index.c b/ompi/mpi/tool/cvar_get_index.c
index ee0672f0c9b..4cb615869f1 100644
--- a/ompi/mpi/tool/cvar_get_index.c
+++ b/ompi/mpi/tool/cvar_get_index.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_cvar_get_index = PMPI_T_cvar_get_index
 #endif
 #define MPI_T_cvar_get_index PMPI_T_cvar_get_index
diff --git a/ompi/mpi/tool/cvar_get_info.c b/ompi/mpi/tool/cvar_get_info.c
index c3f94787587..80ae844bbb7 100644
--- a/ompi/mpi/tool/cvar_get_info.c
+++ b/ompi/mpi/tool/cvar_get_info.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_cvar_get_info = PMPI_T_cvar_get_info
 #endif
 #define MPI_T_cvar_get_info PMPI_T_cvar_get_info
diff --git a/ompi/mpi/tool/cvar_get_num.c b/ompi/mpi/tool/cvar_get_num.c
index 32ba1201cdc..4be619d4fa4 100644
--- a/ompi/mpi/tool/cvar_get_num.c
+++ b/ompi/mpi/tool/cvar_get_num.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_cvar_get_num = PMPI_T_cvar_get_num
 #endif
 #define MPI_T_cvar_get_num PMPI_T_cvar_get_num
diff --git a/ompi/mpi/tool/cvar_handle_alloc.c b/ompi/mpi/tool/cvar_handle_alloc.c
index 82ebe890032..d47ba2ddb17 100644
--- a/ompi/mpi/tool/cvar_handle_alloc.c
+++ b/ompi/mpi/tool/cvar_handle_alloc.c
@@ -23,7 +23,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_cvar_handle_alloc = PMPI_T_cvar_handle_alloc
 #endif
 #define MPI_T_cvar_handle_alloc PMPI_T_cvar_handle_alloc
diff --git a/ompi/mpi/tool/cvar_handle_free.c b/ompi/mpi/tool/cvar_handle_free.c
index 7ffa6c4c30a..f6283389feb 100644
--- a/ompi/mpi/tool/cvar_handle_free.c
+++ b/ompi/mpi/tool/cvar_handle_free.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_cvar_handle_free = PMPI_T_cvar_handle_free
 #endif
 #define MPI_T_cvar_handle_free PMPI_T_cvar_handle_free
diff --git a/ompi/mpi/tool/cvar_read.c b/ompi/mpi/tool/cvar_read.c
index 90b39d47a22..6955a48a3ac 100644
--- a/ompi/mpi/tool/cvar_read.c
+++ b/ompi/mpi/tool/cvar_read.c
@@ -22,7 +22,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_cvar_read = PMPI_T_cvar_read
 #endif
 #define MPI_T_cvar_read PMPI_T_cvar_read
diff --git a/ompi/mpi/tool/cvar_write.c b/ompi/mpi/tool/cvar_write.c
index 5dadb1e48e5..acd908b924a 100644
--- a/ompi/mpi/tool/cvar_write.c
+++ b/ompi/mpi/tool/cvar_write.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_cvar_write = PMPI_T_cvar_write
 #endif
 #define MPI_T_cvar_write PMPI_T_cvar_write
diff --git a/ompi/mpi/tool/enum_get_info.c b/ompi/mpi/tool/enum_get_info.c
index 59de6eebe80..72e400eb42b 100644
--- a/ompi/mpi/tool/enum_get_info.c
+++ b/ompi/mpi/tool/enum_get_info.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_enum_get_info = PMPI_T_enum_get_info
 #endif
 #define MPI_T_enum_get_info PMPI_T_enum_get_info
diff --git a/ompi/mpi/tool/enum_get_item.c b/ompi/mpi/tool/enum_get_item.c
index 0a6e23c806e..8cb6d9a06f3 100644
--- a/ompi/mpi/tool/enum_get_item.c
+++ b/ompi/mpi/tool/enum_get_item.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_enum_get_item = PMPI_T_enum_get_item
 #endif
 #define MPI_T_enum_get_item PMPI_T_enum_get_item
diff --git a/ompi/mpi/tool/event_callback_get_info.c b/ompi/mpi/tool/event_callback_get_info.c
index 92519a13aac..6b4ccbe1a77 100644
--- a/ompi/mpi/tool/event_callback_get_info.c
+++ b/ompi/mpi/tool/event_callback_get_info.c
@@ -19,7 +19,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_callback_get_info = PMPI_T_event_callback_get_info
 #endif
 #define MPI_T_event_callback_get_info PMPI_T_event_callback_get_info
diff --git a/ompi/mpi/tool/event_callback_set_info.c b/ompi/mpi/tool/event_callback_set_info.c
index 5f78d2c92de..f718c05a205 100644
--- a/ompi/mpi/tool/event_callback_set_info.c
+++ b/ompi/mpi/tool/event_callback_set_info.c
@@ -19,7 +19,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_callback_set_info = PMPI_T_event_callback_set_info
 #endif
 #define MPI_T_event_callback_set_info PMPI_T_event_callback_set_info
diff --git a/ompi/mpi/tool/event_copy.c b/ompi/mpi/tool/event_copy.c
index f0c64bad822..5d01acfd3d4 100644
--- a/ompi/mpi/tool/event_copy.c
+++ b/ompi/mpi/tool/event_copy.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_copy = PMPI_T_event_copy
 #endif
 #define MPI_T_event_copy PMPI_T_event_copy
diff --git a/ompi/mpi/tool/event_get_index.c b/ompi/mpi/tool/event_get_index.c
index 0c0ec50cf39..660d1966cd5 100644
--- a/ompi/mpi/tool/event_get_index.c
+++ b/ompi/mpi/tool/event_get_index.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_get_index = PMPI_T_event_get_index
 #endif
 #define MPI_T_event_get_index PMPI_T_event_get_index
diff --git a/ompi/mpi/tool/event_get_info.c b/ompi/mpi/tool/event_get_info.c
index f7fd9134379..75ed9b90cdf 100644
--- a/ompi/mpi/tool/event_get_info.c
+++ b/ompi/mpi/tool/event_get_info.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_get_info = PMPI_T_event_get_info
 #endif
 #define MPI_T_event_get_info PMPI_T_event_get_info
diff --git a/ompi/mpi/tool/event_get_num.c b/ompi/mpi/tool/event_get_num.c
index 0b27caa60fc..b00ba32b62c 100644
--- a/ompi/mpi/tool/event_get_num.c
+++ b/ompi/mpi/tool/event_get_num.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_get_num = PMPI_T_event_get_num
 #endif
 #define MPI_T_event_get_num PMPI_T_event_get_num
diff --git a/ompi/mpi/tool/event_get_source.c b/ompi/mpi/tool/event_get_source.c
index 7ec12af587e..671c2ec5891 100644
--- a/ompi/mpi/tool/event_get_source.c
+++ b/ompi/mpi/tool/event_get_source.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_get_source = PMPI_T_event_get_source
 #endif
 #define MPI_T_event_get_source PMPI_T_event_get_source
diff --git a/ompi/mpi/tool/event_get_timestamp.c b/ompi/mpi/tool/event_get_timestamp.c
index 34fd49d5075..c90be9fe02e 100644
--- a/ompi/mpi/tool/event_get_timestamp.c
+++ b/ompi/mpi/tool/event_get_timestamp.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_get_timestamp = PMPI_T_event_get_timestamp
 #endif
 #define MPI_T_event_get_timestamp PMPI_T_event_get_timestamp
diff --git a/ompi/mpi/tool/event_handle_alloc.c b/ompi/mpi/tool/event_handle_alloc.c
index 0768cf2f879..26d8ea1a8a1 100644
--- a/ompi/mpi/tool/event_handle_alloc.c
+++ b/ompi/mpi/tool/event_handle_alloc.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_handle_alloc = PMPI_T_event_handle_alloc
 #endif
 #define MPI_T_event_handle_alloc PMPI_T_event_handle_alloc
diff --git a/ompi/mpi/tool/event_handle_free.c b/ompi/mpi/tool/event_handle_free.c
index 7fb756b3938..2b3ba6ec2b6 100644
--- a/ompi/mpi/tool/event_handle_free.c
+++ b/ompi/mpi/tool/event_handle_free.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_handle_free = PMPI_T_event_handle_free
 #endif
 #define MPI_T_event_handle_free PMPI_T_event_handle_free
diff --git a/ompi/mpi/tool/event_handle_get_info.c b/ompi/mpi/tool/event_handle_get_info.c
index 2009d67b1ef..6e9c3deecbe 100644
--- a/ompi/mpi/tool/event_handle_get_info.c
+++ b/ompi/mpi/tool/event_handle_get_info.c
@@ -19,7 +19,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_handle_get_info = PMPI_T_event_handle_get_info
 #endif
 #define MPI_T_event_handle_get_info PMPI_T_event_handle_get_info
diff --git a/ompi/mpi/tool/event_handle_set_info.c b/ompi/mpi/tool/event_handle_set_info.c
index 0c35e27d2a1..12521e93b61 100644
--- a/ompi/mpi/tool/event_handle_set_info.c
+++ b/ompi/mpi/tool/event_handle_set_info.c
@@ -19,7 +19,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_handle_set_info = PMPI_T_event_handle_set_info
 #endif
 #define MPI_T_event_handle_set_info PMPI_T_event_handle_set_info
diff --git a/ompi/mpi/tool/event_read.c b/ompi/mpi/tool/event_read.c
index e16d3e33f50..618458c71ce 100644
--- a/ompi/mpi/tool/event_read.c
+++ b/ompi/mpi/tool/event_read.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_read = PMPI_T_event_read
 #endif
 #define MPI_T_event_read PMPI_T_event_read
diff --git a/ompi/mpi/tool/event_register_callback.c b/ompi/mpi/tool/event_register_callback.c
index 4550fabe520..8cfa32c2ba3 100644
--- a/ompi/mpi/tool/event_register_callback.c
+++ b/ompi/mpi/tool/event_register_callback.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_register_callback = PMPI_T_event_register_callback
 #endif
 #define MPI_T_event_register_callback PMPI_T_event_register_callback
diff --git a/ompi/mpi/tool/event_set_dropped_handler.c b/ompi/mpi/tool/event_set_dropped_handler.c
index fe15695abb8..cecc2f560c7 100644
--- a/ompi/mpi/tool/event_set_dropped_handler.c
+++ b/ompi/mpi/tool/event_set_dropped_handler.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_event_set_dropped_handler = PMPI_T_event_set_dropped_handler
 #endif
 #define MPI_T_event_set_dropped_handler PMPI_T_event_set_dropped_handler
diff --git a/ompi/mpi/tool/finalize.c b/ompi/mpi/tool/finalize.c
index 359468b494d..4f92d37c425 100644
--- a/ompi/mpi/tool/finalize.c
+++ b/ompi/mpi/tool/finalize.c
@@ -22,7 +22,7 @@
 #include "opal/runtime/opal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_finalize = PMPI_T_finalize
 #endif
 #define MPI_T_finalize PMPI_T_finalize
diff --git a/ompi/mpi/tool/init_thread.c b/ompi/mpi/tool/init_thread.c
index 9ef39846f38..e2e870aa21d 100644
--- a/ompi/mpi/tool/init_thread.c
+++ b/ompi/mpi/tool/init_thread.c
@@ -25,7 +25,7 @@
 #include "opal/runtime/opal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_init_thread = PMPI_T_init_thread
 #endif
 #define MPI_T_init_thread PMPI_T_init_thread
diff --git a/ompi/mpi/tool/pvar_get_index.c b/ompi/mpi/tool/pvar_get_index.c
index 4f7832c4b7c..f8951044578 100644
--- a/ompi/mpi/tool/pvar_get_index.c
+++ b/ompi/mpi/tool/pvar_get_index.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_get_index = PMPI_T_pvar_get_index
 #endif
 #define MPI_T_pvar_get_index PMPI_T_pvar_get_index
diff --git a/ompi/mpi/tool/pvar_get_info.c b/ompi/mpi/tool/pvar_get_info.c
index 01ad175e2d6..1437d398203 100644
--- a/ompi/mpi/tool/pvar_get_info.c
+++ b/ompi/mpi/tool/pvar_get_info.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_get_info = PMPI_T_pvar_get_info
 #endif
 #define MPI_T_pvar_get_info PMPI_T_pvar_get_info
diff --git a/ompi/mpi/tool/pvar_get_num.c b/ompi/mpi/tool/pvar_get_num.c
index 1e3fa0b1fb3..bcbf3a70640 100644
--- a/ompi/mpi/tool/pvar_get_num.c
+++ b/ompi/mpi/tool/pvar_get_num.c
@@ -20,7 +20,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_get_num = PMPI_T_pvar_get_num
 #endif
 #define MPI_T_pvar_get_num PMPI_T_pvar_get_num
diff --git a/ompi/mpi/tool/pvar_handle_alloc.c b/ompi/mpi/tool/pvar_handle_alloc.c
index b37e05a57e2..6887fde8cf9 100644
--- a/ompi/mpi/tool/pvar_handle_alloc.c
+++ b/ompi/mpi/tool/pvar_handle_alloc.c
@@ -23,7 +23,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_handle_alloc = PMPI_T_pvar_handle_alloc
 #endif
 #define MPI_T_pvar_handle_alloc PMPI_T_pvar_handle_alloc
diff --git a/ompi/mpi/tool/pvar_handle_free.c b/ompi/mpi/tool/pvar_handle_free.c
index 81ffa0707a9..d712d6d798c 100644
--- a/ompi/mpi/tool/pvar_handle_free.c
+++ b/ompi/mpi/tool/pvar_handle_free.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_handle_free = PMPI_T_pvar_handle_free
 #endif
 #define MPI_T_pvar_handle_free PMPI_T_pvar_handle_free
diff --git a/ompi/mpi/tool/pvar_read.c b/ompi/mpi/tool/pvar_read.c
index 0c4e53653e0..97be0da7200 100644
--- a/ompi/mpi/tool/pvar_read.c
+++ b/ompi/mpi/tool/pvar_read.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_read = PMPI_T_pvar_read
 #endif
 #define MPI_T_pvar_read PMPI_T_pvar_read
diff --git a/ompi/mpi/tool/pvar_readreset.c b/ompi/mpi/tool/pvar_readreset.c
index 1567c4b1aef..4fba1410166 100644
--- a/ompi/mpi/tool/pvar_readreset.c
+++ b/ompi/mpi/tool/pvar_readreset.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_readreset = PMPI_T_pvar_readreset
 #endif
 #define MPI_T_pvar_readreset PMPI_T_pvar_readreset
@@ -26,10 +26,37 @@
 int MPI_T_pvar_readreset(MPI_T_pvar_session session, MPI_T_pvar_handle handle,
                          void *buf)
 {
+    int ret;
+
     if (!mpit_is_initialized ()) {
         return MPI_T_ERR_NOT_INITIALIZED;
     }
 
-    /* XXX -- TODO -- Implement me */
-    return MPI_T_ERR_INVALID_HANDLE;
-}
+    // MPI_T_PVAR_ALL_HANDLES is explicitly disallowed for readreset
+    // (no single buffer to fill).
+    if (MPI_T_PVAR_ALL_HANDLES == handle || NULL == handle || session != handle->session) {
+        return MPI_T_ERR_INVALID_HANDLE;
+    }
+
+    ompi_mpit_lock ();
+
+    if (!mca_base_pvar_is_atomic (handle->pvar)) {
+        ompi_mpit_unlock ();
+        return MPI_T_ERR_PVAR_NO_ATOMIC;   // direct: not via ompit_opal_to_mpit_error
+    }
+
+    // Readreset is not allowed on read-only pvars
+    if (mca_base_pvar_is_readonly (handle->pvar)) {
+        ompi_mpit_unlock ();
+        return MPI_T_ERR_PVAR_NO_WRITE;
+    }
+
+    ret = mca_base_pvar_handle_read_value (handle, buf);
+    if (OPAL_SUCCESS == ret) {
+        ret = mca_base_pvar_handle_reset (handle);
+    }
+
+    ompi_mpit_unlock ();
+
+    return ompit_opal_to_mpit_error (ret);
+}
\ No newline at end of file
diff --git a/ompi/mpi/tool/pvar_reset.c b/ompi/mpi/tool/pvar_reset.c
index a6f59d5405d..2b17f292041 100644
--- a/ompi/mpi/tool/pvar_reset.c
+++ b/ompi/mpi/tool/pvar_reset.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_reset = PMPI_T_pvar_reset
 #endif
 #define MPI_T_pvar_reset PMPI_T_pvar_reset
diff --git a/ompi/mpi/tool/pvar_session_create.c b/ompi/mpi/tool/pvar_session_create.c
index 6c153bebb8f..be2e47c3fe8 100644
--- a/ompi/mpi/tool/pvar_session_create.c
+++ b/ompi/mpi/tool/pvar_session_create.c
@@ -21,7 +21,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_session_create = PMPI_T_pvar_session_create
 #endif
 #define MPI_T_pvar_session_create PMPI_T_pvar_session_create
diff --git a/ompi/mpi/tool/pvar_session_free.c b/ompi/mpi/tool/pvar_session_free.c
index 459489d6a8b..e0333cb17b1 100644
--- a/ompi/mpi/tool/pvar_session_free.c
+++ b/ompi/mpi/tool/pvar_session_free.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_session_free = PMPI_T_pvar_session_free
 #endif
 #define MPI_T_pvar_session_free PMPI_T_pvar_session_free
diff --git a/ompi/mpi/tool/pvar_start.c b/ompi/mpi/tool/pvar_start.c
index ecf99372c08..fbf81d11097 100644
--- a/ompi/mpi/tool/pvar_start.c
+++ b/ompi/mpi/tool/pvar_start.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_start = PMPI_T_pvar_start
 #endif
 #define MPI_T_pvar_start PMPI_T_pvar_start
diff --git a/ompi/mpi/tool/pvar_stop.c b/ompi/mpi/tool/pvar_stop.c
index 349e6f2d0ec..9fd904e59f1 100644
--- a/ompi/mpi/tool/pvar_stop.c
+++ b/ompi/mpi/tool/pvar_stop.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_stop = PMPI_T_pvar_stop
 #endif
 #define MPI_T_pvar_stop PMPI_T_pvar_stop
diff --git a/ompi/mpi/tool/pvar_write.c b/ompi/mpi/tool/pvar_write.c
index 4bd3f8d75e1..33673d37f8d 100644
--- a/ompi/mpi/tool/pvar_write.c
+++ b/ompi/mpi/tool/pvar_write.c
@@ -18,7 +18,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_pvar_write = PMPI_T_pvar_write
 #endif
 #define MPI_T_pvar_write PMPI_T_pvar_write
diff --git a/ompi/mpi/tool/source_get_info.c b/ompi/mpi/tool/source_get_info.c
index 94017246fa2..6acaf764967 100644
--- a/ompi/mpi/tool/source_get_info.c
+++ b/ompi/mpi/tool/source_get_info.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_source_get_info = PMPI_T_source_get_info
 #endif
 #define MPI_T_source_get_info PMPI_T_source_get_info
diff --git a/ompi/mpi/tool/source_get_num.c b/ompi/mpi/tool/source_get_num.c
index 6b31862ff27..bfa5cf77e0d 100644
--- a/ompi/mpi/tool/source_get_num.c
+++ b/ompi/mpi/tool/source_get_num.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_source_get_num = PMPI_T_source_get_num
 #endif
 #define MPI_T_source_get_num PMPI_T_source_get_num
diff --git a/ompi/mpi/tool/source_get_timestamp.c b/ompi/mpi/tool/source_get_timestamp.c
index 02a4303d286..28e31016192 100644
--- a/ompi/mpi/tool/source_get_timestamp.c
+++ b/ompi/mpi/tool/source_get_timestamp.c
@@ -17,7 +17,7 @@
 #include "ompi/mpi/tool/mpit-internal.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPI_T_source_get_timestamp = PMPI_T_source_get_timestamp
 #endif
 #define MPI_T_source_get_timestamp PMPI_T_source_get_timestamp
diff --git a/ompi/mpiext/AGENTS.md b/ompi/mpiext/AGENTS.md
new file mode 100644
index 00000000000..bfdb48662b5
--- /dev/null
+++ b/ompi/mpiext/AGENTS.md
@@ -0,0 +1,60 @@
+# AGENTS.md — Open MPI extensions (`ompi/mpiext/`)
+
+Scoped guidance for AI coding agents (and humans) working on the MPI
+*extensions* tree. This complements the top-level
+[`AGENTS.md`](../../CLAUDE.md) / `CLAUDE.md`; when the two disagree, the
+top-level file and the docs under [`docs/`](../../docs/) win.
+
+An MPI extension is a self-contained set of non-standard, Open
+MPI-specific APIs and/or constants exposed to user applications via the
+separate `mpi-ext.h` header (and the Fortran `mpif-ext.h` /
+`use mpi_ext` / `use mpi_f08_ext` equivalents). Each subdirectory here
+is one extension; its name is its directory name. See
+[`example/README.md`](example/README.md) for the canonical walk-through
+of an extension's required layout, and [`README.md`](README.md) for the
+symbol-naming rules (`OMPI_` vs. `MPIX_` vs. `MPI_`).
+
+## Current extensions and where each is documented
+
+The canonical, user-facing *index* of all extensions is
+[`docs/features/extensions.rst`](../../docs/features/extensions.rst)
+(rendered under "Open MPI-specific features → Open MPI extensions").
+**Every buildable extension must be listed there.**
+
+## Documentation-sync checklist
+
+When you **add, remove, or change the public API/constants of an
+extension** in this tree, update the docs in the same PR:
+
+1. **`docs/features/extensions.rst`** — the "Available extensions" list.
+   Add/remove/adjust the bullet so it matches what actually builds. This
+   is the single most-often-missed step.
+2. **Man pages** — every public `MPIX_*` / `OMPI_*` symbol should have a
+   page under [`docs/man-openmpi/man3/`](../../docs/man-openmpi/man3/),
+   listed in that directory's `index.rst`. New API → new man page.
+3. **Accelerator extensions** (`cuda`, `rocm`) — keep the relevant
+   `docs/tuning-apps/accelerators/*.rst` page in sync.
+4. **`ftmpi`** — user-facing behavior is documented in
+   [`docs/features/ulfm.rst`](../../docs/features/ulfm.rst), not just the
+   man pages.
+5. **Changelog** — add a release-notes entry under
+   [`docs/release-notes/changelog/`](../../docs/release-notes/changelog/)
+   (`vMAJOR.MINOR.x.rst`) for any user-visible change.
+6. **LLM-friendly docs** — if you touch public MPI-extension
+   documentation, check whether the curated sources under
+   [`docs/llms-src/`](../../docs/llms-src/) (e.g. the interface guide)
+   need a matching update; see
+   [`docs/developers/llm-friendly-docs.rst`](../../docs/developers/llm-friendly-docs.rst).
+
+## How an extension is selected to be built
+
+Each extension has a mandatory `configure.m4` whose macro decides,
+during Open MPI's `configure`, whether the extension builds. Extensions
+are enabled by default and can be disabled globally with
+`--disable-mpi-ext` (or selectively via its argument list). Individual
+extensions typically also gate themselves on a prerequisite — e.g.
+`cuda`/`rocm` on the corresponding accelerator support being configured,
+`shortfloat` on the compiler actually providing `_Float16` / `short
+float`. When you document an extension, describe *when* it is present,
+not just what it does — that build-selection story is currently
+under-documented.
diff --git a/ompi/mpiext/CLAUDE.md b/ompi/mpiext/CLAUDE.md
new file mode 120000
index 00000000000..47dc3e3d863
--- /dev/null
+++ b/ompi/mpiext/CLAUDE.md
@@ -0,0 +1 @@
+AGENTS.md
\ No newline at end of file
diff --git a/ompi/mpiext/README.md b/ompi/mpiext/README.md
index ff4e7827c4b..edce5ccb100 100644
--- a/ompi/mpiext/README.md
+++ b/ompi/mpiext/README.md
@@ -100,7 +100,7 @@ The rationale was threefold:
    answer").  But since the `MPIX_Foo` -> `MPI_Foo` change is
    inevitable, it just ends up annoying users.
 1. Once OMPI introduces `MPIX_` symbols, if we want to *not* annoy
-   users, we'll likely have weak symbols / aliased versions of both
+   users, we'll likely have weak aliases / aliased versions of both
    `MPIX_Foo` and `MPI_Foo` once the Foo functionality is included in
    a published MPI specification.  However, when can we delete the
    `MPIX_Foo` symbol?  It becomes a continuing annoyance of backwards
diff --git a/ompi/mpiext/example/mpif-h/mpiext_example_progress_f.c b/ompi/mpiext/example/mpif-h/mpiext_example_progress_f.c
index 395e9932b97..5aad270fe5b 100644
--- a/ompi/mpiext/example/mpif-h/mpiext_example_progress_f.c
+++ b/ompi/mpiext/example/mpif-h/mpiext_example_progress_f.c
@@ -23,7 +23,7 @@
 
 #include "ompi/mpiext/example/c/mpiext_example_c.h"
 
-/* Rather than doing a whole pile of messy things with weak symbols,
+/* Rather than doing a whole pile of messy things with weak aliases,
    just define one back-end function (the _f version), and then four
    short functions for the four popular Fortran symbol-mangling
    schemes that call the back-end function.  Make sure that the the
diff --git a/ompi/mpiext/ftmpi/c/comm_ack_failed.c b/ompi/mpiext/ftmpi/c/comm_ack_failed.c
index d4f6c625034..4b8704d3e65 100644
--- a/ompi/mpiext/ftmpi/c/comm_ack_failed.c
+++ b/ompi/mpiext/ftmpi/c/comm_ack_failed.c
@@ -19,7 +19,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_ack_failed = PMPIX_Comm_ack_failed
 #endif
 #define MPIX_Comm_ack_failed PMPIX_Comm_ack_failed
diff --git a/ompi/mpiext/ftmpi/c/comm_agree.c b/ompi/mpiext/ftmpi/c/comm_agree.c
index d2817d76474..d7ff668e643 100644
--- a/ompi/mpiext/ftmpi/c/comm_agree.c
+++ b/ompi/mpiext/ftmpi/c/comm_agree.c
@@ -21,7 +21,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_agree = PMPIX_Comm_agree
 #endif
 #define MPIX_Comm_agree PMPIX_Comm_agree
diff --git a/ompi/mpiext/ftmpi/c/comm_failure_ack.c b/ompi/mpiext/ftmpi/c/comm_failure_ack.c
index bb581c1df0c..a5c4fed09eb 100644
--- a/ompi/mpiext/ftmpi/c/comm_failure_ack.c
+++ b/ompi/mpiext/ftmpi/c/comm_failure_ack.c
@@ -20,7 +20,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_failure_ack = PMPIX_Comm_failure_ack
 #endif
 #define MPIX_Comm_failure_ack PMPIX_Comm_failure_ack
diff --git a/ompi/mpiext/ftmpi/c/comm_failure_get_acked.c b/ompi/mpiext/ftmpi/c/comm_failure_get_acked.c
index 489819ff283..35ee0892d51 100644
--- a/ompi/mpiext/ftmpi/c/comm_failure_get_acked.c
+++ b/ompi/mpiext/ftmpi/c/comm_failure_get_acked.c
@@ -19,7 +19,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_failure_get_acked = PMPIX_Comm_failure_get_acked
 #endif
 #define MPIX_Comm_failure_get_acked PMPIX_Comm_failure_get_acked
diff --git a/ompi/mpiext/ftmpi/c/comm_get_failed.c b/ompi/mpiext/ftmpi/c/comm_get_failed.c
index 999a627545f..86ada80a844 100644
--- a/ompi/mpiext/ftmpi/c/comm_get_failed.c
+++ b/ompi/mpiext/ftmpi/c/comm_get_failed.c
@@ -18,7 +18,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_get_failed = PMPIX_Comm_get_failed
 #endif
 #define MPIX_Comm_get_failed PMPIX_Comm_get_failed
diff --git a/ompi/mpiext/ftmpi/c/comm_iagree.c b/ompi/mpiext/ftmpi/c/comm_iagree.c
index b385451744a..7f7321b7c55 100644
--- a/ompi/mpiext/ftmpi/c/comm_iagree.c
+++ b/ompi/mpiext/ftmpi/c/comm_iagree.c
@@ -20,7 +20,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_iagree = PMPIX_Comm_iagree
 #endif
 #define MPIX_Comm_iagree PMPIX_Comm_iagree
diff --git a/ompi/mpiext/ftmpi/c/comm_is_revoked.c b/ompi/mpiext/ftmpi/c/comm_is_revoked.c
index 9cdc7267d24..4760e3baf94 100644
--- a/ompi/mpiext/ftmpi/c/comm_is_revoked.c
+++ b/ompi/mpiext/ftmpi/c/comm_is_revoked.c
@@ -18,7 +18,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_is_revoked = PMPIX_Comm_is_revoked
 #endif
 #define MPIX_Comm_is_revoked PMPIX_Comm_is_revoked
diff --git a/ompi/mpiext/ftmpi/c/comm_ishrink.c b/ompi/mpiext/ftmpi/c/comm_ishrink.c
index c1c80ce9fb7..e6501316975 100644
--- a/ompi/mpiext/ftmpi/c/comm_ishrink.c
+++ b/ompi/mpiext/ftmpi/c/comm_ishrink.c
@@ -18,7 +18,7 @@
 #include "ompi/op/op.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_ishrink = PMPIX_Comm_ishrink
 #endif
 #define MPIX_Comm_ishrink PMPIX_Comm_ishrink
diff --git a/ompi/mpiext/ftmpi/c/comm_revoke.c b/ompi/mpiext/ftmpi/c/comm_revoke.c
index 46dafe8b3e7..42c6eadbb2c 100644
--- a/ompi/mpiext/ftmpi/c/comm_revoke.c
+++ b/ompi/mpiext/ftmpi/c/comm_revoke.c
@@ -18,7 +18,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_revoke = PMPIX_Comm_revoke
 #endif
 #define MPIX_Comm_revoke PMPIX_Comm_revoke
diff --git a/ompi/mpiext/ftmpi/c/comm_shrink.c b/ompi/mpiext/ftmpi/c/comm_shrink.c
index 83e39eac6b3..867fb03070d 100644
--- a/ompi/mpiext/ftmpi/c/comm_shrink.c
+++ b/ompi/mpiext/ftmpi/c/comm_shrink.c
@@ -19,7 +19,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 
 #if OMPI_BUILD_MPI_PROFILING
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak MPIX_Comm_shrink = PMPIX_Comm_shrink
 #endif
 #define MPIX_Comm_shrink PMPIX_Comm_shrink
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_ack_failed_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_ack_failed_f.c
index f1c244a50b8..dabb7a53a4a 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_ack_failed_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_ack_failed_f.c
@@ -15,7 +15,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_ACK_FAILED = ompix_comm_ack_failed_f
 #pragma weak pmpix_comm_ack_failed = ompix_comm_ack_failed_f
 #pragma weak pmpix_comm_ack_failed_ = ompix_comm_ack_failed_f
@@ -30,7 +30,7 @@
 #pragma weak MPIX_Comm_ack_failed_f = ompix_comm_ack_failed_f
 #pragma weak MPIX_Comm_ack_failed_f08 = ompix_comm_ack_failed_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_ACK_FAILED,
                         pmpix_comm_ack_failed,
                         pmpix_comm_ack_failed_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_agree_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_agree_f.c
index db8ff982f2c..94c9bf7a8f3 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_agree_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_agree_f.c
@@ -15,7 +15,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_AGREE = ompix_comm_agree_f
 #pragma weak pmpix_comm_agree = ompix_comm_agree_f
 #pragma weak pmpix_comm_agree_ = ompix_comm_agree_f
@@ -30,7 +30,7 @@
 #pragma weak MPIX_Comm_agree_f = ompix_comm_agree_f
 #pragma weak MPIX_Comm_agree_f08 = ompix_comm_agree_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_AGREE,
                         pmpix_comm_agree,
                         pmpix_comm_agree_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_failure_ack_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_failure_ack_f.c
index 3d916cdd0f8..b973e4c6ae1 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_failure_ack_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_failure_ack_f.c
@@ -15,7 +15,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_FAILURE_ACK = ompix_comm_failure_ack_f
 #pragma weak pmpix_comm_failure_ack = ompix_comm_failure_ack_f
 #pragma weak pmpix_comm_failure_ack_ = ompix_comm_failure_ack_f
@@ -30,7 +30,7 @@
 #pragma weak MPIX_Comm_failure_ack_f = ompix_comm_failure_ack_f
 #pragma weak MPIX_Comm_failure_ack_f08 = ompix_comm_failure_ack_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_FAILURE_ACK,
                         pmpix_comm_failure_ack,
                         pmpix_comm_failure_ack_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_failure_get_acked_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_failure_get_acked_f.c
index c51e70c1d21..6c149005a24 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_failure_get_acked_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_failure_get_acked_f.c
@@ -16,7 +16,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_FAILURE_GET_ACKED = ompix_comm_failure_get_acked_f
 #pragma weak pmpix_comm_failure_get_acked = ompix_comm_failure_get_acked_f
 #pragma weak pmpix_comm_failure_get_acked_ = ompix_comm_failure_get_acked_f
@@ -31,7 +31,7 @@
 #pragma weak MPIX_Comm_failure_get_acked_f = ompix_comm_failure_get_acked_f
 #pragma weak MPIX_Comm_failure_get_acked_f08 = ompix_comm_failure_get_acked_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_FAILURE_GET_ACKED,
                         pmpix_comm_failure_get_acked,
                         pmpix_comm_failure_get_acked_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_get_failed_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_get_failed_f.c
index 8473a7f749c..0e89d67eb64 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_get_failed_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_get_failed_f.c
@@ -15,7 +15,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_GET_FAILED = ompix_comm_get_failed_f
 #pragma weak pmpix_comm_get_failed = ompix_comm_get_failed_f
 #pragma weak pmpix_comm_get_failed_ = ompix_comm_get_failed_f
@@ -30,7 +30,7 @@
 #pragma weak MPIX_Comm_get_failed_f = ompix_comm_get_failed_f
 #pragma weak MPIX_Comm_get_failed_f08 = ompix_comm_get_failed_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_GET_FAILED,
                         pmpix_comm_get_failed,
                         pmpix_comm_get_failed_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_iagree_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_iagree_f.c
index e6a95596c64..13882d8e3da 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_iagree_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_iagree_f.c
@@ -15,7 +15,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_IAGREE = ompix_comm_iagree_f
 #pragma weak pmpix_comm_iagree = ompix_comm_iagree_f
 #pragma weak pmpix_comm_iagree_ = ompix_comm_iagree_f
@@ -30,7 +30,7 @@
 #pragma weak MPIX_Comm_iagree_f = ompix_comm_iagree_f
 #pragma weak MPIX_Comm_iagree_f08 = ompix_comm_iagree_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(MPIX_COMM_IAGREE,
                         mpix_comm_iagree,
                         mpix_comm_iagree_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_is_revoked_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_is_revoked_f.c
index 4ec922a3054..5c1d80230e0 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_is_revoked_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_is_revoked_f.c
@@ -17,7 +17,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_IS_REVOKED = ompix_comm_is_revoked_f
 #pragma weak pmpix_comm_is_revoked = ompix_comm_is_revoked_f
 #pragma weak pmpix_comm_is_revoked_ = ompix_comm_is_revoked_f
@@ -32,7 +32,7 @@
 #pragma weak MPIX_Comm_is_revoked_f = ompix_comm_is_revoked_f
 #pragma weak MPIX_Comm_is_revoked_f08 = ompix_comm_is_revoked_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_IS_REVOKED,
                         pmpix_comm_is_revoked,
                         pmpix_comm_is_revoked_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_ishrink_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_ishrink_f.c
index 30977617969..e8b625c43d8 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_ishrink_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_ishrink_f.c
@@ -20,7 +20,7 @@
 #include "ompi/request/request.h"
 #include "ompi/mpi/fortran/base/fint_2_int.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_ISHRINK = ompix_comm_ishrink_f
 #pragma weak pmpix_comm_ishrink = ompix_comm_ishrink_f
 #pragma weak pmpix_comm_ishrink_ = ompix_comm_ishrink_f
@@ -35,7 +35,7 @@
 #pragma weak MPIX_Comm_ishrink_f = ompix_comm_ishrink_f
 #pragma weak MPIX_Comm_ishrink_f08 = ompix_comm_ishrink_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_ISHRINK,
                         pmpix_comm_ishrink,
                         pmpix_comm_ishrink_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_revoke_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_revoke_f.c
index 08b585554e2..5c0eebdc48e 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_revoke_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_revoke_f.c
@@ -15,7 +15,7 @@
 #include "ompi/mpiext/ftmpi/c/mpiext_ftmpi_c.h"
 #include "ompi/mpiext/ftmpi/mpif-h/prototypes_mpi.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_REVOKE = ompix_comm_revoke_f
 #pragma weak pmpix_comm_revoke = ompix_comm_revoke_f
 #pragma weak pmpix_comm_revoke_ = ompix_comm_revoke_f
@@ -30,7 +30,7 @@
 #pragma weak MPIX_Comm_revoke_f = ompix_comm_revoke_f
 #pragma weak MPIX_Comm_revoke_f08 = ompix_comm_revoke_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_REVOKE,
                         pmpix_comm_revoke,
                         pmpix_comm_revoke_,
diff --git a/ompi/mpiext/ftmpi/mpif-h/comm_shrink_f.c b/ompi/mpiext/ftmpi/mpif-h/comm_shrink_f.c
index f4d8c5b1c44..976a776d14f 100644
--- a/ompi/mpiext/ftmpi/mpif-h/comm_shrink_f.c
+++ b/ompi/mpiext/ftmpi/mpif-h/comm_shrink_f.c
@@ -18,7 +18,7 @@
 
 #include "ompi/communicator/communicator.h"
 
-#if OPAL_HAVE_WEAK_SYMBOLS
+#if OPAL_HAVE_WEAK_ALIASES
 #pragma weak PMPIX_COMM_SHRINK = ompix_comm_shrink_f
 #pragma weak pmpix_comm_shrink = ompix_comm_shrink_f
 #pragma weak pmpix_comm_shrink_ = ompix_comm_shrink_f
@@ -33,7 +33,7 @@
 #pragma weak MPIX_Comm_shrink_f = ompix_comm_shrink_f
 #pragma weak MPIX_Comm_shrink_f08 = ompix_comm_shrink_f
 
-#else /* No weak symbols */
+#else /* No weak aliases */
 OMPI_GENERATE_F77_BINDINGS(PMPIX_COMM_SHRINK,
                         pmpix_comm_shrink,
                         pmpix_comm_shrink_,
diff --git a/ompi/op/op.c b/ompi/op/op.c
index 3ace78f5933..8d986f17ff9 100644
--- a/ompi/op/op.c
+++ b/ompi/op/op.c
@@ -20,6 +20,7 @@
  * Copyright (c) 2018-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -401,25 +402,6 @@ ompi_op_t *ompi_op_create_user(bool commute,
 }
 
 
-/*
- * See lengthy comment in mpi/cxx/intercepts.cc for how the C++ MPI::Op
- * callbacks work.
- */
-void ompi_op_set_java_callback(ompi_op_t *op, void *jnienv,
-                               void *object, int baseType)
-{
-    op->o_flags |= OMPI_OP_FLAGS_JAVA_FUNC;
-    /* The OMPI Java intercept was previously stored in
-       op->o_func.fort_fn by ompi_op_create_user().  So save that in
-       cxx.intercept_fn and put the user's fn in cxx.user_fn. */
-    op->o_func.java_data.intercept_fn =
-        (ompi_op_java_handler_fn_t *) op->o_func.fort_fn;
-    op->o_func.java_data.jnienv = jnienv;
-    op->o_func.java_data.object = object;
-    op->o_func.java_data.baseType = baseType;
-}
-
-
 /**************************************************************************
  *
  * Static functions
diff --git a/ompi/op/op.h b/ompi/op/op.h
index bf895d7c6f3..d5ab76f17cd 100644
--- a/ompi/op/op.h
+++ b/ompi/op/op.h
@@ -21,6 +21,7 @@
  * Copyright (c) 2018-2025 Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2021      IBM Corporation.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -72,15 +73,6 @@ typedef void (ompi_op_fortran_handler_fn_t)(const void *, void *,
 typedef void (ompi_op_fortran_handler_bc_fn_t)(const void *, void *,
                                                size_t *, MPI_Fint *);
 
-/**
- * Typedef for Java op functions intercept (used for user-defined
- * MPI.Ops).
- */
-typedef void (ompi_op_java_handler_fn_t)(const void *, void *, int *,
-                                         struct ompi_datatype_t **,
-                                         int baseType,
-                                         void *jnienv, void *object);
-
 /*
  * Flags for MPI_Op
  */
@@ -88,8 +80,6 @@ typedef void (ompi_op_java_handler_fn_t)(const void *, void *, int *,
 #define OMPI_OP_FLAGS_INTRINSIC    0x0001
 /** Set if the callback function is in Fortran */
 #define OMPI_OP_FLAGS_FORTRAN_FUNC 0x0002
-/** Set if the callback function is in Java */
-#define OMPI_OP_FLAGS_JAVA_FUNC    0x0008
 /** Set if the callback function is associative (MAX and SUM will both
     have ASSOC set -- in fact, it will only *not* be set if we
     implement some extensions to MPI, because MPI says that all
@@ -162,14 +152,6 @@ struct ompi_op_t {
         ompi_op_fortran_handler_fn_t *fort_fn;
         /** Fortran handler function pointer  - bigcount*/
         ompi_op_fortran_handler_bc_fn_t *fort_fn_bc;
-        /** Java intercept function data */
-        struct {
-            /* The OMPI C++ callback/intercept function */
-            ompi_op_java_handler_fn_t *intercept_fn;
-            /* The Java run time environment */
-            void *jnienv, *object;
-            int baseType;
-        } java_data;
     } o_func;
 
     /** 3-buffer functions, which is only for intrinsic ops.  No need
@@ -368,13 +350,6 @@ ompi_op_t *ompi_op_create_user(bool commute,
                                bool bigcount,
                                ompi_op_fortran_handler_fn_t func);
 
-/**
- * Mark an MPI_Op as holding a Java callback function, and cache that
- * function in the MPI_Op.
- */
-OMPI_DECLSPEC void ompi_op_set_java_callback(ompi_op_t *op,  void *jnienv,
-                                             void *object, int baseType);
-
 /**
  * Check to see if an op is intrinsic.
  *
@@ -594,12 +569,6 @@ static inline void ompi_op_reduce(ompi_op_t * op, const void *source,
             op->o_func.fort_fn_bc(source, target, &full_count, &f_dtype);
         }
         return;
-    } else if (0 != (op->o_flags & OMPI_OP_FLAGS_JAVA_FUNC)) {
-        op->o_func.java_data.intercept_fn(source, target, &count, &dtype,
-                                          op->o_func.java_data.baseType,
-                                          op->o_func.java_data.jnienv,
-                                          op->o_func.java_data.object);
-        return;
     }
     if (0 == (op->o_flags & OMPI_OP_FLAGS_BIGCOUNT)) {
         op->o_func.c_fn(source, target, &count, &dtype);
diff --git a/ompi/request/req_test.c b/ompi/request/req_test.c
index 8eaa37e0d29..0da69b09142 100644
--- a/ompi/request/req_test.c
+++ b/ompi/request/req_test.c
@@ -14,6 +14,7 @@
  * Copyright (c) 2010-2012 Oracle and/or its affiliates.  All rights reserved.
  * Copyright (c) 2012      Oak Ridge National Labs.  All rights reserved.
  * Copyright (c) 2025      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -249,7 +250,7 @@ int ompi_request_default_test_all(
                 ompi_grequest_invoke_query(request, &request->req_status);
             }
             OMPI_COPY_STATUS(&statuses[i], request->req_status, true);
-            if (MPI_SUCCESS == request->req_status.MPI_ERROR) {
+            if (MPI_SUCCESS != request->req_status.MPI_ERROR) {
                 rc = MPI_ERR_IN_STATUS;
 #if OPAL_ENABLE_FT_MPI
                 if (MPI_ERR_PROC_FAILED == request->req_status.MPI_ERROR
diff --git a/ompi/request/req_wait.c b/ompi/request/req_wait.c
index f5b3d43deac..8ac3c9515ac 100644
--- a/ompi/request/req_wait.c
+++ b/ompi/request/req_wait.c
@@ -103,6 +103,7 @@ int ompi_request_default_wait_any(size_t count,
 
 recheck:
     WAIT_SYNC_INIT(&sync, 1);
+    opal_atomic_wmb();  /* release: sync struct init must be visible before CAS publishes &sync */
 
     num_requests_null_inactive = 0;
     for (i = 0; i < count; i++) {
@@ -238,6 +239,7 @@ int ompi_request_default_wait_all( size_t count,
 
 recheck:
     WAIT_SYNC_INIT(&sync, count);
+    opal_atomic_wmb();  /* release: sync struct init must be visible before CAS publishes &sync */
     rptr = requests;
     for (i = 0; i < count; i++) {
         void *_tmp_ptr = REQUEST_PENDING;
@@ -466,6 +468,7 @@ int ompi_request_default_wait_some(size_t count,
 
   recheck:
     WAIT_SYNC_INIT(&sync, 1);
+    opal_atomic_wmb();  /* release: sync struct init must be visible before CAS publishes &sync */
 
     *outcount = 0;
 
diff --git a/ompi/request/request.h b/ompi/request/request.h
index 548c053a7bc..afa4a4a9062 100644
--- a/ompi/request/request.h
+++ b/ompi/request/request.h
@@ -465,6 +465,7 @@ static inline void ompi_request_wait_completion(ompi_request_t *req)
             _tmp_ptr = REQUEST_PENDING;
 
             WAIT_SYNC_INIT(&sync, 1);
+            opal_atomic_wmb();  /* release: sync struct init must be visible before CAS publishes &sync */
 
             if (OPAL_ATOMIC_COMPARE_EXCHANGE_STRONG_PTR(&req->req_complete, &_tmp_ptr, &sync)) {
                 SYNC_WAIT(&sync);
@@ -533,6 +534,7 @@ static inline int ompi_request_complete(ompi_request_t* request, bool with_signa
 
             ompi_wait_sync_t *tmp_sync = (ompi_wait_sync_t *) OPAL_ATOMIC_SWAP_PTR(&request->req_complete,
                                                                                     REQUEST_COMPLETED);
+            opal_atomic_rmb();  /* acquire: pair with wmb before CAS to see sync struct contents */
             if( REQUEST_PENDING != tmp_sync ) {
                 wait_sync_update(tmp_sync, 1, request->req_status.MPI_ERROR);
             }
diff --git a/ompi/runtime/ompi_mpi_params.c b/ompi/runtime/ompi_mpi_params.c
index 7b5d1f3c55e..d33a75efa55 100644
--- a/ompi/runtime/ompi_mpi_params.c
+++ b/ompi/runtime/ompi_mpi_params.c
@@ -24,6 +24,7 @@
  *                         reserved.
  * Copyright (c) 2021      Nanook Consulting.  All rights reserved.
  * Copyright (c) 2022      IBM Corporation.  All rights reserved.
+ * Copyright (c) 2026      Sandia National Laboratories.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -157,9 +158,9 @@ int ompi_mpi_register_params(void)
     /* yield if the node is oversubscribed and allow users to override */
     (void) mca_base_var_register("ompi", "mpi", NULL, "yield_when_idle",
                                  "Yield the processor when waiting for MPI communication (for MPI processes, will default to 1 when oversubscribing nodes)",
-                                 MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
-                                 OPAL_INFO_LVL_5,
-                                 MCA_BASE_VAR_SCOPE_READONLY,
+                                 MCA_BASE_VAR_TYPE_BOOL, NULL, 0,
+                                 MCA_BASE_VAR_FLAG_SETTABLE, OPAL_INFO_LVL_5,
+                                 MCA_BASE_VAR_SCOPE_LOCAL,
                                  &ompi_mpi_yield_when_idle);
 
     ompi_mpi_event_tick_rate = -1;
diff --git a/ompi/runtime/ompi_spc.c b/ompi/runtime/ompi_spc.c
index 6f1d8aa7d6a..5e6a3dbb339 100644
--- a/ompi/runtime/ompi_spc.c
+++ b/ompi/runtime/ompi_spc.c
@@ -71,9 +71,13 @@ static const ompi_spc_event_t ompi_spc_events_desc[OMPI_SPC_NUM_COUNTERS] = {
     SET_COUNTER_ARRAY(OMPI_SPC_SENDRECV, "The number of times MPI_Sendrecv was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_SENDRECV_REPLACE, "The number of times MPI_Sendrecv_replace was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_PUT, "The number of times MPI_Put was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_PUT_NOTIFY, "The number of times MPI_Put_notify was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_RPUT, "The number of times MPI_Rput was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_RPUT_NOTIFY, "The number of times MPI_Rput_notify was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_GET, "The number of times MPI_Get was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_GET_NOTIFY, "The number of times MPI_Get_notify was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_RGET, "The number of times MPI_Rget was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_RGET_NOTIFY, "The number of times MPI_Rget_notify was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_PROBE, "The number of times MPI_Probe was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_IPROBE, "The number of times MPI_Iprobe was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_BCAST, "The number of times MPI_Bcast was called.", false, false),
@@ -170,7 +174,11 @@ static const ompi_spc_event_t ompi_spc_events_desc[OMPI_SPC_NUM_COUNTERS] = {
     SET_COUNTER_ARRAY(OMPI_SPC_ISENDRECV, "The number of times MPI_Isendrecv was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_ISENDRECV_REPLACE, "The number of times MPI_Isendrecv_replace was called.", false, false),
     SET_COUNTER_ARRAY(OMPI_SPC_PARRIVED, "The number of times MPI_Parrived was called.", false, false),
-    SET_COUNTER_ARRAY(OMPI_SPC_PREADY, "The number of times MPI_Pready (or similar functions) was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_PREADY, "The number of times MPI_Pready was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_PREADY_LIST, "The number of times MPI_Pready_list was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_PREADY_RANGE, "The number of times MPI_Pready_range was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_PRECV_INIT, "The number of times MPI_Precv_init was called.", false, false),
+    SET_COUNTER_ARRAY(OMPI_SPC_PSEND_INIT, "The number of times MPI_Psend_init was called.", false, false)
 };
 
 /* An array of event structures to store the event data (value, attachments, flags) */
diff --git a/ompi/runtime/ompi_spc.h b/ompi/runtime/ompi_spc.h
index 76ec7f25f16..5aebb282de8 100644
--- a/ompi/runtime/ompi_spc.h
+++ b/ompi/runtime/ompi_spc.h
@@ -58,9 +58,13 @@ typedef enum ompi_spc_counters {
     OMPI_SPC_SENDRECV,
     OMPI_SPC_SENDRECV_REPLACE,
     OMPI_SPC_PUT,
+    OMPI_SPC_PUT_NOTIFY,
     OMPI_SPC_RPUT,
+    OMPI_SPC_RPUT_NOTIFY,
     OMPI_SPC_GET,
+    OMPI_SPC_GET_NOTIFY,
     OMPI_SPC_RGET,
+    OMPI_SPC_RGET_NOTIFY,
     OMPI_SPC_PROBE,
     OMPI_SPC_IPROBE,
     OMPI_SPC_BCAST,
@@ -156,6 +160,10 @@ typedef enum ompi_spc_counters {
     OMPI_SPC_ISENDRECV_REPLACE,
     OMPI_SPC_PARRIVED,
     OMPI_SPC_PREADY,
+    OMPI_SPC_PREADY_LIST,
+    OMPI_SPC_PREADY_RANGE,
+    OMPI_SPC_PRECV_INIT,
+    OMPI_SPC_PSEND_INIT,
     OMPI_SPC_NUM_COUNTERS /* This serves as the number of counters.  It must be last. */
 } ompi_spc_counters_t;
 
diff --git a/ompi/test/Makefile.am b/ompi/test/Makefile.am
new file mode 100644
index 00000000000..91aa3da5e01
--- /dev/null
+++ b/ompi/test/Makefile.am
@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+# Single-process unit tests for the OMPI layer.  These tests live inside
+# the ompi/ subtree, alongside the code that they exercise, and are run
+# by "make check" (both a top-level "make check" and one run solely
+# inside ompi/).
+#
+# Every test here is a self-checking single-process program: it needs no
+# launcher, and any MPI communication it performs is on MPI_COMM_SELF.
+# Tests are grouped into subdirectories by the MPI object or interface
+# that they exercise.
+#
+
+# t, file, datatype, and general are run by "make check".  spc and
+# monitoring are multi-process tests: they are built, but not run by
+# "make check".
+SUBDIRS = t file datatype general monitoring spc
diff --git a/ompi/test/datatype/Makefile.am b/ompi/test/datatype/Makefile.am
new file mode 100644
index 00000000000..ee8cc46775d
--- /dev/null
+++ b/ompi/test/datatype/Makefile.am
@@ -0,0 +1,114 @@
+#
+# Copyright (c) 2004-2009 The University of Tennessee and The University
+#                         of Tennessee Research Foundation.  All rights
+#                         reserved.
+# Copyright (c) 2006-2015 Cisco Systems, Inc.  All rights reserved.
+# Copyright (c) 2009      Oak Ridge National Labs.  All rights reserved.
+# Copyright (c) 2014-2019 Research Organization for Information Science
+#                         and Technology (RIST).  All rights reserved.
+# Copyright (c) 2016      IBM Corporation.  All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+# Single-process tests of the OMPI datatype engine (ompi/datatype) and
+# the MPI datatype API.  The OPAL-level datatype tests, which link only
+# against libopen-pal, remain in test/datatype.
+#
+
+# mpi_datatype_bigcount calls MPI_Init().  Make "make check" work in an
+# uninstalled --enable-mca-dso build tree.
+include $(top_srcdir)/Makefile.mca-dso-check
+
+# to_self and reduce_local are built but not run, as they were in
+# test/datatype before this directory existed.  (reduce_local is driven
+# by getopt() command-line arguments; see check_op.sh.)
+TESTS = \
+        checksum \
+        position \
+        position_noncontig \
+        ddt_test \
+        ddt_raw \
+        ddt_raw2 \
+        unpack_ooo \
+        ddt_pack \
+        external32 \
+        large_data \
+        partial \
+        ompi_datatype_bigcount \
+        mpi_datatype_bigcount
+
+MPI_CHECKS = to_self reduce_local
+
+check_PROGRAMS = $(TESTS) $(MPI_CHECKS)
+
+common_ldflags = $(OMPI_PKG_CONFIG_LDFLAGS)
+common_ldadd = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+
+unpack_ooo_SOURCES = unpack_ooo.c ddt_lib.c ddt_lib.h
+unpack_ooo_LDFLAGS = $(common_ldflags)
+unpack_ooo_LDADD = $(common_ldadd)
+
+ddt_test_SOURCES = ddt_test.c ddt_lib.c ddt_lib.h
+ddt_test_LDFLAGS = $(common_ldflags)
+ddt_test_LDADD = $(common_ldadd)
+
+ddt_raw_SOURCES = ddt_raw.c ddt_lib.c ddt_lib.h
+ddt_raw_LDFLAGS = $(common_ldflags)
+ddt_raw_LDADD = $(common_ldadd)
+
+ddt_raw2_SOURCES = ddt_raw2.c ddt_lib.c ddt_lib.h
+ddt_raw2_LDFLAGS = $(common_ldflags)
+ddt_raw2_LDADD = $(common_ldadd)
+
+ddt_pack_SOURCES = ddt_pack.c
+ddt_pack_LDFLAGS = $(common_ldflags)
+ddt_pack_LDADD = $(common_ldadd)
+
+checksum_SOURCES = checksum.c
+checksum_LDFLAGS = $(common_ldflags)
+checksum_LDADD = $(common_ldadd)
+
+position_SOURCES = position.c
+position_LDFLAGS = $(common_ldflags)
+position_LDADD = $(common_ldadd)
+
+position_noncontig_SOURCES = position_noncontig.c
+position_noncontig_LDFLAGS = $(common_ldflags)
+position_noncontig_LDADD = $(common_ldadd)
+
+to_self_SOURCES = to_self.c
+to_self_LDFLAGS = $(common_ldflags)
+to_self_LDADD = $(common_ldadd)
+
+large_data_SOURCES = large_data.c
+large_data_LDFLAGS = $(common_ldflags)
+large_data_LDADD = $(common_ldadd)
+
+ompi_datatype_bigcount_SOURCES = ompi_datatype_bigcount.c
+ompi_datatype_bigcount_LDFLAGS = $(common_ldflags)
+ompi_datatype_bigcount_LDADD = $(common_ldadd)
+
+mpi_datatype_bigcount_SOURCES = mpi_datatype_bigcount.c
+mpi_datatype_bigcount_LDFLAGS = $(common_ldflags)
+mpi_datatype_bigcount_LDADD = $(common_ldadd)
+
+external32_SOURCES = external32.c
+external32_LDFLAGS = $(common_ldflags)
+external32_LDADD = $(common_ldadd)
+
+reduce_local_SOURCES = reduce_local.c
+reduce_local_LDFLAGS = $(common_ldflags)
+reduce_local_LDADD = $(common_ldadd)
+
+partial_SOURCES = partial.c
+partial_LDFLAGS = $(common_ldflags)
+partial_LDADD = $(common_ldadd)
+
+distclean-local:
+	rm -rf *.dSYM .deps .libs *.log *.o *.trs $(check_PROGRAMS) Makefile
diff --git a/test/datatype/check_op.sh b/ompi/test/datatype/check_op.sh
similarity index 100%
rename from test/datatype/check_op.sh
rename to ompi/test/datatype/check_op.sh
diff --git a/test/datatype/checksum.c b/ompi/test/datatype/checksum.c
similarity index 99%
rename from test/datatype/checksum.c
rename to ompi/test/datatype/checksum.c
index 39c47c2f730..cc1d3eaf0a2 100644
--- a/test/datatype/checksum.c
+++ b/ompi/test/datatype/checksum.c
@@ -151,7 +151,7 @@ int main(int argc, char *argv[])
     free(packed);
 
     /* clean-ups all data allocations */
-    opal_finalize_util();
+    opal_finalize();
 
     return 0;
 }
diff --git a/test/datatype/ddt_lib.c b/ompi/test/datatype/ddt_lib.c
similarity index 90%
rename from test/datatype/ddt_lib.c
rename to ompi/test/datatype/ddt_lib.c
index 0a0e9dc7e01..fae69584544 100644
--- a/test/datatype/ddt_lib.c
+++ b/ompi/test/datatype/ddt_lib.c
@@ -14,6 +14,7 @@
  * Copyright (c) 2009      Oak Ridge National Labs.  All rights reserved.
  * Copyright (c) 2018      Los Alamos National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -134,7 +135,8 @@ ompi_datatype_t *upper_matrix(unsigned int mat_size)
         blocklen[i] = mat_size - i;
     }
 
-    ompi_datatype_create_indexed(mat_size, blocklen, disp, &ompi_mpi_double.dt, &upper);
+    ompi_datatype_create_indexed(mat_size, OMPI_COUNT_ARRAY_CREATE(blocklen),
+                                 OMPI_DISP_ARRAY_CREATE(disp), &ompi_mpi_double.dt, &upper);
     ompi_datatype_commit(&upper);
     if (outputFlags & DUMP_DATA_AFTER_COMMIT) {
         ompi_datatype_dump(upper);
@@ -158,7 +160,8 @@ ompi_datatype_t *lower_matrix(unsigned int mat_size)
         blocklen[i] = i;
     }
 
-    ompi_datatype_create_indexed(mat_size, blocklen, disp, &ompi_mpi_double.dt, &upper);
+    ompi_datatype_create_indexed(mat_size, OMPI_COUNT_ARRAY_CREATE(blocklen),
+                                 OMPI_DISP_ARRAY_CREATE(disp), &ompi_mpi_double.dt, &upper);
     free(disp);
     free(blocklen);
     return upper;
@@ -175,7 +178,8 @@ ompi_datatype_t *test_matrix_borders(unsigned int size, unsigned int width)
     disp[1] = (size - width) * sizeof(double);
     blocklen[1] = width;
 
-    ompi_datatype_create_indexed(2, blocklen, disp, &ompi_mpi_double.dt, &pdt_line);
+    ompi_datatype_create_indexed(2, OMPI_COUNT_ARRAY_CREATE(blocklen),
+                                 OMPI_DISP_ARRAY_CREATE(disp), &ompi_mpi_double.dt, &pdt_line);
     ompi_datatype_create_contiguous(size, pdt_line, &pdt);
     OBJ_RELEASE(pdt_line); /*assert( pdt_line == NULL );*/
     return pdt;
@@ -224,7 +228,8 @@ ompi_datatype_t *test_struct_char_double(void)
     displ[0] = (char *) &(data.c) - (char *) &(data);
     displ[1] = (char *) &(data.d) - (char *) &(data);
 
-    ompi_datatype_create_struct(2, lengths, displ, types, &pdt);
+    ompi_datatype_create_struct(2, OMPI_COUNT_ARRAY_CREATE(lengths),
+                                OMPI_DISP_ARRAY_CREATE(displ), types, &pdt);
     ompi_datatype_commit(&pdt);
     if (outputFlags & DUMP_DATA_AFTER_COMMIT) {
         ompi_datatype_dump(pdt);
@@ -276,7 +281,8 @@ ompi_datatype_t *test_create_blacs_type(void)
 {
     ompi_datatype_t *pdt;
 
-    ompi_datatype_create_indexed(18, blacs_length, blacs_indices, &ompi_mpi_int.dt, &pdt);
+    ompi_datatype_create_indexed(18, OMPI_COUNT_ARRAY_CREATE(blacs_length),
+                                 OMPI_DISP_ARRAY_CREATE(blacs_indices), &ompi_mpi_int.dt, &pdt);
     ompi_datatype_commit(&pdt);
     if (outputFlags & DUMP_DATA_AFTER_COMMIT) {
         ompi_datatype_dump(pdt);
@@ -327,7 +333,8 @@ ompi_datatype_t *test_struct(void)
 
     types[1] = pdt1;
 
-    ompi_datatype_create_struct(3, lengths, disp, types, &pdt);
+    ompi_datatype_create_struct(3, OMPI_COUNT_ARRAY_CREATE(lengths),
+                                OMPI_DISP_ARRAY_CREATE(disp), types, &pdt);
     OBJ_RELEASE(pdt1); /*assert( pdt1 == NULL );*/
     if (outputFlags & DUMP_DATA_AFTER_COMMIT) {
         ompi_datatype_dump(pdt);
@@ -356,7 +363,8 @@ ompi_datatype_t *create_struct_constant_gap_resized_ddt(ompi_datatype_t *type)
     disps[1] -= disps[2]; /*  8 */
     disps[0] -= disps[2]; /* 16 */
 
-    ompi_datatype_create_struct(2, blocklens, disps, types, &temp_type);
+    ompi_datatype_create_struct(2, OMPI_COUNT_ARRAY_CREATE(blocklens),
+                                OMPI_DISP_ARRAY_CREATE(disps), types, &temp_type);
     ompi_datatype_create_resized(temp_type, 0, sizeof(data[0]), &struct_type);
     ompi_datatype_commit(&struct_type);
     OBJ_RELEASE(temp_type);
@@ -394,7 +402,7 @@ ompi_datatype_t *create_strange_dt(void)
 
     dispi[0] = (int) ((char *) &(v[0].i1) - (char *) &(v[0]));                   /* 0 */
     dispi[1] = (int) (((char *) (&(v[0].i2)) - (char *) &(v[0])) / sizeof(int)); /* 2 */
-    ompi_datatype_create_indexed_block(2, 1, dispi, &ompi_mpi_int.dt, &pdtTemp);
+    ompi_datatype_create_indexed_block(2, 1, OMPI_DISP_ARRAY_CREATE(dispi), &ompi_mpi_int.dt, &pdtTemp);
 #ifdef USE_RESIZED
     /* optional */
     displ[0] = 0;
@@ -411,7 +419,8 @@ ompi_datatype_t *create_strange_dt(void)
     displ[0] = 0;
     displ[1] = (long) ((char *) &(t[0].v[0]) - (char *) &(t[0]));
     displ[2] = (long) ((char *) &(t[0].last) - (char *) &(t[0]));
-    ompi_datatype_create_struct(3, pBlock, displ, types, &pdtTemp);
+    ompi_datatype_create_struct(3, OMPI_COUNT_ARRAY_CREATE(pBlock),
+                                OMPI_DISP_ARRAY_CREATE(displ), types, &pdtTemp);
 #ifdef USE_RESIZED
     /* optional */
     displ[1] = (char *) &(t[1]) - (char *) &(t[0]);
diff --git a/test/datatype/ddt_lib.h b/ompi/test/datatype/ddt_lib.h
similarity index 100%
rename from test/datatype/ddt_lib.h
rename to ompi/test/datatype/ddt_lib.h
diff --git a/test/datatype/ddt_pack.c b/ompi/test/datatype/ddt_pack.c
similarity index 86%
rename from test/datatype/ddt_pack.c
rename to ompi/test/datatype/ddt_pack.c
index bdb6bc462ea..acc16a6f9b4 100644
--- a/test/datatype/ddt_pack.c
+++ b/ompi/test/datatype/ddt_pack.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2018      Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2020      Intel, Inc.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -118,14 +119,14 @@ int main(int argc, char *argv[])
     types[1] = &ompi_mpi_int.dt;
     types[2] = &ompi_mpi_int.dt;
     types[3] = &ompi_mpi_int.dt;
-    ret = ompi_datatype_create_struct(4, blen, disp, types, &struct_type);
+    ret = ompi_datatype_create_struct(4, OMPI_COUNT_ARRAY_CREATE(blen), OMPI_DISP_ARRAY_CREATE(disp), types, &struct_type);
     if (ret != 0)
         goto cleanup;
 
     {
         int count = 4;
-        const int *a_i[2] = {&count, blen};
-        ret = ompi_datatype_set_args(struct_type, count + 1, a_i, count, disp, count, types,
+        const ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&count), OMPI_COUNT_ARRAY_CREATE(blen)};
+        ret = ompi_datatype_set_args(struct_type, count + 1, 0, a_i, count, OMPI_DISP_ARRAY_CREATE(disp), count, types,
                                      MPI_COMBINER_STRUCT);
         if (ret != 0)
             goto cleanup;
@@ -190,9 +191,11 @@ int main(int argc, char *argv[])
         int count = 2;
         int blocklength = 1;
         int stride = 1;
-        const int *a_i[3] = {&count, &blocklength, &stride};
+        const ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                           OMPI_COUNT_ARRAY_CREATE(&blocklength),
+                                           OMPI_COUNT_ARRAY_CREATE(&stride)};
         ompi_datatype_t *type = &ompi_mpi_int.dt;
-        ret = ompi_datatype_set_args(vec_type, 3, a_i, 0, NULL, 1, &type, MPI_COMBINER_VECTOR);
+        ret = ompi_datatype_set_args(vec_type, 3, 0, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &type, MPI_COMBINER_VECTOR);
         if (ret != 0)
             goto cleanup;
     }
@@ -251,16 +254,18 @@ int main(int argc, char *argv[])
     blen[0] = 0;
     blen[1] = 20 * sizeof(double);
 
-    ret = ompi_datatype_create_indexed_block(2, 10, blen, &ompi_mpi_double.dt, &newType);
+    ret = ompi_datatype_create_indexed_block(2, 10, OMPI_COUNT_ARRAY_CREATE(blen), &ompi_mpi_double.dt, &newType);
     if (ret != 0)
         goto cleanup;
 
     {
         int count = 2;
         int blocklength = 10;
-        const int *a_i[3] = {&count, &blocklength, blen};
+        const ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                           OMPI_COUNT_ARRAY_CREATE(&blocklength),
+                                           OMPI_COUNT_ARRAY_CREATE(blen)};
         ompi_datatype_t *oldtype = &ompi_mpi_double.dt;
-        ompi_datatype_set_args(newType, 2 + count, a_i, 0, NULL, 1, &oldtype,
+        ompi_datatype_set_args(newType, 2 + count, 0, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &oldtype,
                                MPI_COMBINER_INDEXED_BLOCK);
         if (ret != 0)
             goto cleanup;
@@ -322,15 +327,16 @@ int main(int argc, char *argv[])
     disp[0] = 0;
     disp[1] = 20 * sizeof(double);
 
-    ret = ompi_datatype_create_hindexed(2, blen, disp, &ompi_mpi_double.dt, &newType);
+    ret = ompi_datatype_create_hindexed(2, OMPI_COUNT_ARRAY_CREATE(blen),
+                                        OMPI_DISP_ARRAY_CREATE(disp), &ompi_mpi_double.dt, &newType);
     if (ret != 0)
         goto cleanup;
 
     {
         int count = 2;
-        const int *a_i[2] = {&count, blen};
+        const ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&count), OMPI_COUNT_ARRAY_CREATE(blen)};
         ompi_datatype_t *oldtype = &ompi_mpi_double.dt;
-        ret = ompi_datatype_set_args(newType, count + 1, a_i, count, disp, 1, &oldtype,
+        ret = ompi_datatype_set_args(newType, count + 1, 0, a_i, count, OMPI_DISP_ARRAY_CREATE(disp), 1, &oldtype,
                                      MPI_COMBINER_HINDEXED);
         if (ret != 0)
             goto cleanup;
@@ -388,14 +394,14 @@ int main(int argc, char *argv[])
     disp[1] = 64;
     types[0] = &ompi_mpi_int.dt;
     types[1] = newType;
-    ret = ompi_datatype_create_struct(2, blen, disp, types, &struct_type);
+    ret = ompi_datatype_create_struct(2, OMPI_COUNT_ARRAY_CREATE(blen), OMPI_DISP_ARRAY_CREATE(disp), types, &struct_type);
     if (ret != 0)
         goto cleanup;
 
     {
         int count = 2;
-        const int *a_i[2] = {&count, blen};
-        ret = ompi_datatype_set_args(struct_type, count + 1, a_i, count, disp, count, types,
+        const ompi_count_array_t a_i[2] = {OMPI_COUNT_ARRAY_CREATE(&count), OMPI_COUNT_ARRAY_CREATE(blen)};
+        ret = ompi_datatype_set_args(struct_type, count + 1, 0, a_i, count, OMPI_DISP_ARRAY_CREATE(disp), count, types,
                                      MPI_COMBINER_STRUCT);
         if (ret != 0)
             goto cleanup;
@@ -461,7 +467,7 @@ int main(int argc, char *argv[])
     if (ret != 0)
         goto cleanup;
     ompi_datatype_t *type = &ompi_mpi_int.dt;
-    ret = ompi_datatype_set_args(dup_type, 0, NULL, 0, NULL, 1, &type, MPI_COMBINER_DUP);
+    ret = ompi_datatype_set_args(dup_type, 0, 0, NULL, 0, OMPI_DISP_ARRAY_NULL, 1, &type, MPI_COMBINER_DUP);
     if (ret != 0)
         goto cleanup;
     packed_ddt_len = ompi_datatype_pack_description_length(dup_type);
@@ -500,7 +506,7 @@ int main(int argc, char *argv[])
     ompi_datatype_destroy(&dup_type);
 
 cleanup:
-    opal_finalize_util();
+    opal_finalize();
 
     return ret;
 }
diff --git a/test/datatype/ddt_raw.c b/ompi/test/datatype/ddt_raw.c
similarity index 99%
rename from test/datatype/ddt_raw.c
rename to ompi/test/datatype/ddt_raw.c
index f4847be3b2b..ccb1e35b13d 100644
--- a/test/datatype/ddt_raw.c
+++ b/ompi/test/datatype/ddt_raw.c
@@ -342,7 +342,7 @@ int main(int argc, char *argv[])
     assert(pdt1 == NULL);
 
     /* clean-ups all data allocations */
-    opal_finalize_util();
+    opal_finalize();
 
     return OMPI_SUCCESS;
 }
diff --git a/test/datatype/ddt_raw2.c b/ompi/test/datatype/ddt_raw2.c
similarity index 100%
rename from test/datatype/ddt_raw2.c
rename to ompi/test/datatype/ddt_raw2.c
diff --git a/test/datatype/ddt_test.c b/ompi/test/datatype/ddt_test.c
similarity index 99%
rename from test/datatype/ddt_test.c
rename to ompi/test/datatype/ddt_test.c
index d8c879e3cfc..5f440a454f6 100644
--- a/test/datatype/ddt_test.c
+++ b/ompi/test/datatype/ddt_test.c
@@ -579,7 +579,7 @@ int main(int argc, char *argv[])
     assert(pdt2 == NULL);
 
     /* clean-ups all data allocations */
-    opal_finalize_util();
+    opal_finalize();
 
     return OMPI_SUCCESS;
 }
diff --git a/test/datatype/external32.c b/ompi/test/datatype/external32.c
similarity index 95%
rename from test/datatype/external32.c
rename to ompi/test/datatype/external32.c
index 9ef83afac57..091b9b9c216 100644
--- a/test/datatype/external32.c
+++ b/ompi/test/datatype/external32.c
@@ -3,6 +3,7 @@
  * Copyright (c) 2016      The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -230,10 +231,12 @@ int main(int argc, char *argv[])
 
         ompi_datatype_create_vector(count, blocklength, stride, &ompi_mpi_int.dt, &ddt);
         {
-            const int *a_i[3] = {&count, &blocklength, &stride};
+            const ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                               OMPI_COUNT_ARRAY_CREATE(&blocklength),
+                                               OMPI_COUNT_ARRAY_CREATE(&stride)};
             ompi_datatype_t *type = &ompi_mpi_int.dt;
 
-            ompi_datatype_set_args(ddt, 3, a_i, 0, NULL, 1, &type, MPI_COMBINER_VECTOR);
+            ompi_datatype_set_args(ddt, 3, 0, a_i, 0, OMPI_DISP_ARRAY_NULL, 1, &type, MPI_COMBINER_VECTOR);
         }
         ompi_datatype_commit(&ddt);
 
@@ -260,7 +263,7 @@ int main(int argc, char *argv[])
         }
     }
 
-    opal_finalize_util();
+    opal_finalize();
 
     return 0;
 }
diff --git a/test/datatype/large_data.c b/ompi/test/datatype/large_data.c
similarity index 94%
rename from test/datatype/large_data.c
rename to ompi/test/datatype/large_data.c
index 5558d6a6455..99e3db9a778 100644
--- a/test/datatype/large_data.c
+++ b/ompi/test/datatype/large_data.c
@@ -3,6 +3,7 @@
  * Copyright (c) 2018      The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -105,7 +106,7 @@ int main(int argc, char *argv[])
     /*
      * Large sparse datatype: indexed contiguous
      */
-    ompi_datatype_create_indexed(2, scounts, sdispls, ddt, &stype);
+    ompi_datatype_create_indexed(2, OMPI_COUNT_ARRAY_CREATE(scounts), OMPI_DISP_ARRAY_CREATE(sdispls), ddt, &stype);
     ompi_datatype_commit(&stype);
 
     packed = count_length_via_convertor_raw("1. INDEX", stype, 1);
@@ -121,7 +122,7 @@ int main(int argc, char *argv[])
     /*
      * Large contiguous datatype: indexed contiguous
      */
-    ompi_datatype_create_indexed(2, rcounts, rdispls, ddt, &rtype);
+    ompi_datatype_create_indexed(2, OMPI_COUNT_ARRAY_CREATE(rcounts), OMPI_DISP_ARRAY_CREATE(rdispls), ddt, &rtype);
     ompi_datatype_commit(&rtype);
 
     packed = count_length_via_convertor_raw("2. INDEX", rtype, 1);
diff --git a/ompi/test/datatype/mpi_datatype_bigcount.c b/ompi/test/datatype/mpi_datatype_bigcount.c
new file mode 100644
index 00000000000..cfe3a2c5b59
--- /dev/null
+++ b/ompi/test/datatype/mpi_datatype_bigcount.c
@@ -0,0 +1,1275 @@
+/* -*- Mode: C; c-basic-offset:4 ; -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/**
+ * "Big count" datatype tests exercised through the public MPI C API.
+ *
+ * Unlike the other test/datatype programs, this one calls MPI_Init /
+ * MPI_Finalize so that it drives the actual generated C bindings --
+ * including the large-count (_c) entry points and the
+ * MPI_Type_get_contents[_c] wrappers.  It runs as a singleton (one
+ * process, no mpirun), so it is suitable for "make check".
+ *
+ * Coverage:
+ *   A. MPI_Type_contiguous_c() with a count above INT_MAX: MPI_Type_size_c,
+ *      MPI_Type_get_envelope_c and MPI_Type_get_contents_c must round-trip
+ *      the large count through the MPI_Count ("large count") array.
+ *   B. Regression test for the #14055 over-read on the large-count path:
+ *      MPI_Type_get_contents_c() called with output arrays *larger* than
+ *      the type's real argument counts (legal per the standard, since the
+ *      required sizes are discovered via get_envelope) must not walk past
+ *      the real constituent datatypes into uninitialized handles.
+ *   C. The same regression on the classic (non-_c) MPI_Type_get_contents()
+ *      path, which had the identical bug.
+ */
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <mpi.h>
+
+static int failures = 0;
+
+#define CHECK(cond)                                                       \
+    do {                                                                  \
+        if (!(cond)) {                                                    \
+            fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__,       \
+                    #cond);                                               \
+            ++failures;                                                   \
+        }                                                                 \
+    } while (0)
+
+/* Big count is only supported where size_t is 64-bit (matches the helper in
+ * the sibling opal_/ompi_datatype_bigcount.c tests). */
+static bool have_64bit_counts(void)
+{
+    return 8 == sizeof(size_t);
+}
+
+/* A recognizable non-NULL garbage handle used to poison surplus output
+ * slots.  If get_contents walks into these, it dereferences garbage --
+ * which is exactly the #14055 crash. */
+static MPI_Datatype const POISON = (MPI_Datatype) (intptr_t) 0xdeadbeef;
+
+/* (A) Large-count contiguous type via the _c API. */
+static void test_contiguous_c_bigcount(void)
+{
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped)\n");
+        return;
+    }
+
+    MPI_Count count = (MPI_Count) INT_MAX + 4096;
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_contiguous_c(count, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    MPI_Count size = 0;
+    CHECK(MPI_SUCCESS == MPI_Type_size_c(t, &size));
+    CHECK(count == size); /* MPI_BYTE has size 1 */
+
+    MPI_Count lb = 1, extent = -1;
+    CHECK(MPI_SUCCESS == MPI_Type_get_extent_c(t, &lb, &extent));
+    CHECK(0 == lb);
+    CHECK(count == extent);
+
+    MPI_Count ni = -1, na = -1, nlc = -1, nd = -1;
+    int combiner = -1;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_envelope_c(t, &ni, &na, &nlc, &nd, &combiner));
+    CHECK(MPI_COMBINER_CONTIGUOUS == combiner);
+    CHECK(1 == nd);
+    /* The _c constructor stored the count as a large count, so it must be
+     * reported in num_large_counts, not num_integers. */
+    CHECK(1 == nlc);
+    CHECK(0 == ni);
+    CHECK(0 == na);
+
+    int aint_ints[1];
+    MPI_Aint addrs[1];
+    MPI_Count larges[1] = {0};
+    MPI_Datatype types[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, ni, na, nlc, nd, aint_ints, addrs,
+                                     larges, types));
+    CHECK(count == larges[0]);
+    CHECK(MPI_BYTE == types[0]);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+/* (B) #14055 regression on the large-count path: oversized output arrays. */
+static void test_get_contents_c_oversized(void)
+{
+    enum { SLACK = 16 };
+    MPI_Count bl[2] = {1, 1};
+    /* array_of_displacements[] is const MPI_Count[] for
+     * MPI_Type_create_struct_c -- this is correct per the MPI standard:
+     * the large-count variants of MPI_Type_create_hindexed,
+     * MPI_Type_create_hindexed_block, and MPI_Type_create_struct take
+     * MPI_Count (not MPI_Aint) byte displacements (MPI 5.0 sec 19.2). */
+    MPI_Count disp[2] = {0, (MPI_Count) sizeof(int)};
+    MPI_Datatype intypes[2] = {MPI_INT, MPI_DOUBLE};
+    MPI_Datatype st = MPI_DATATYPE_NULL;
+
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_struct_c(2, bl, disp, intypes, &st));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&st));
+
+    MPI_Count ni = -1, na = -1, nlc = -1, nd = -1;
+    int combiner = -1;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_envelope_c(st, &ni, &na, &nlc, &nd, &combiner));
+    CHECK(MPI_COMBINER_STRUCT == combiner);
+    /* _c struct: count + 2 blocklengths + 2 displacements are all large
+     * counts; no integers or addresses; two constituent datatypes. */
+    CHECK(0 == ni);
+    CHECK(0 == na);
+    CHECK(5 == nlc);
+    CHECK(2 == nd);
+    if (ni < 0 || na < 0 || nlc < 0 || nd < 0) {
+        return; /* envelope failed (already recorded); counts are bogus */
+    }
+
+    /* Allocate every output array oversized and poison the datatype tail. */
+    int *ai = calloc((size_t) ni + SLACK, sizeof(int));
+    MPI_Aint *aa = calloc((size_t) na + SLACK, sizeof(MPI_Aint));
+    MPI_Count *alc = calloc((size_t) nlc + SLACK, sizeof(MPI_Count));
+    MPI_Datatype *ad = malloc(((size_t) nd + SLACK) * sizeof(MPI_Datatype));
+    CHECK(NULL != ai && NULL != aa && NULL != alc && NULL != ad);
+    if (NULL == ai || NULL == aa || NULL == alc || NULL == ad) {
+        free(ai); free(aa); free(alc); free(ad);
+        return;
+    }
+    for (size_t i = 0; i < (size_t) nd + SLACK; ++i) {
+        ad[i] = POISON;
+    }
+
+    /* Pass capacities LARGER than the real counts -- the legal usage that
+     * crashed before #14055. */
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(st, ni + SLACK, na + SLACK, nlc + SLACK,
+                                     nd + SLACK, ai, aa, alc, ad));
+
+    /* Every returned value is checked: count, both blocklengths, both
+     * displacements, and both constituent datatypes. */
+    CHECK(2 == alc[0]);                     /* count */
+    CHECK(bl[0] == alc[1]);                 /* blocklengths */
+    CHECK(bl[1] == alc[2]);
+    CHECK(disp[0] == alc[3]);               /* displacements */
+    CHECK(disp[1] == alc[4]);
+    CHECK(MPI_INT == ad[0]);
+    CHECK(MPI_DOUBLE == ad[1]);
+    /* Surplus datatype slots untouched (no over-read -- the #14055 bug). */
+    for (size_t i = (size_t) nd; i < (size_t) nd + SLACK; ++i) {
+        CHECK(POISON == ad[i]);
+    }
+
+    free(ai);
+    free(aa);
+    free(alc);
+    free(ad);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&st));
+}
+
+/* (C) Same #14055 regression on the classic (non-_c) path. */
+static void test_get_contents_oversized(void)
+{
+    enum { SLACK = 16 };
+    int bl[2] = {1, 1};
+    MPI_Aint disp[2] = {0, (MPI_Aint) sizeof(int)};
+    MPI_Datatype intypes[2] = {MPI_INT, MPI_DOUBLE};
+    MPI_Datatype st = MPI_DATATYPE_NULL;
+
+    CHECK(MPI_SUCCESS == MPI_Type_create_struct(2, bl, disp, intypes, &st));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&st));
+
+    int ni = -1, na = -1, nd = -1, combiner = -1;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_envelope(st, &ni, &na, &nd, &combiner));
+    CHECK(MPI_COMBINER_STRUCT == combiner);
+    /* classic struct: count + 2 blocklengths are integers; the 2 byte
+     * displacements are addresses; two constituent datatypes. */
+    CHECK(3 == ni);
+    CHECK(2 == na);
+    CHECK(2 == nd);
+    if (ni < 0 || na < 0 || nd < 0) {
+        return; /* envelope failed (already recorded); counts are bogus */
+    }
+
+    int *ai = calloc((size_t) ni + SLACK, sizeof(int));
+    MPI_Aint *aa = calloc((size_t) na + SLACK, sizeof(MPI_Aint));
+    MPI_Datatype *ad = malloc(((size_t) nd + SLACK) * sizeof(MPI_Datatype));
+    CHECK(NULL != ai && NULL != aa && NULL != ad);
+    if (NULL == ai || NULL == aa || NULL == ad) {
+        free(ai); free(aa); free(ad);
+        return;
+    }
+    for (size_t i = 0; i < (size_t) nd + SLACK; ++i) {
+        ad[i] = POISON;
+    }
+
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents(st, ni + SLACK, na + SLACK, nd + SLACK, ai,
+                                   aa, ad));
+
+    /* Every returned value is checked. */
+    CHECK(2 == ai[0]);          /* count */
+    CHECK(bl[0] == ai[1]);      /* blocklengths */
+    CHECK(bl[1] == ai[2]);
+    CHECK(disp[0] == aa[0]);    /* displacements */
+    CHECK(disp[1] == aa[1]);
+    CHECK(MPI_INT == ad[0]);
+    CHECK(MPI_DOUBLE == ad[1]);
+    for (size_t i = (size_t) nd; i < (size_t) nd + SLACK; ++i) {
+        CHECK(POISON == ad[i]);
+    }
+
+    free(ai);
+    free(aa);
+    free(ad);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&st));
+}
+
+/* ===================================================================
+ * (D) Large-count round-trip through every derived-type constructor.
+ *
+ * PR #13460 added MPI_Count type-punning to *all* the datatype
+ * constructors, but only contiguous was previously tested with a count
+ * above INT_MAX.  For each combiner we build a type with at least one
+ * argument above INT_MAX (keeping the number of blocks/dims tiny so only
+ * O(1) datatype metadata is allocated -- no large buffers), then verify
+ * the MPI 5.0 decode:
+ *
+ *   - MPI_Type_get_envelope_c reports the standard (ni, na, nlc, nd).
+ *   - MPI_Type_get_contents_c returns every above-INT_MAX argument
+ *     undamaged, in the array the standard requires.
+ *   - MPI_Type_size_c reflects the 64-bit size.
+ *
+ * Per MPI 5.0 sec 19.2, the "_c" datatype constructors type *all* count
+ * and byte-displacement arguments as MPI_Count -- there are no MPI_Aint
+ * arguments left in any "_c" datatype constructor.  Therefore byte
+ * displacements/strides decode into array_of_large_counts and
+ * num_addresses is 0 for every combiner below (including RESIZED, whose
+ * lb/extent are MPI_Count in the _c interface).
+ * =================================================================== */
+
+/* INT_MAX as an MPI_Count; "BIG + k" is safely above INT_MAX. */
+#define BIG ((MPI_Count) INT_MAX)
+
+static void check_env_c(const char *label, MPI_Datatype t,
+                        int expect_combiner, MPI_Count eni, MPI_Count ena,
+                        MPI_Count enlc, MPI_Count end)
+{
+    MPI_Count ni = -1, na = -1, nlc = -1, nd = -1;
+    int combiner = -1;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_envelope_c(t, &ni, &na, &nlc, &nd, &combiner));
+    printf("  %-15s combiner=%2d ni=%lld na=%lld nlc=%lld nd=%lld\n", label,
+           combiner, (long long) ni, (long long) na, (long long) nlc,
+           (long long) nd);
+    fflush(stdout);
+    CHECK(expect_combiner == combiner);
+    CHECK(eni == ni);
+    CHECK(ena == na);
+    CHECK(enlc == nlc);
+    CHECK(end == nd);
+}
+
+/* Verify a type's full footprint: size, lower bound, and extent. */
+static void check_size_extent_c(MPI_Datatype t, MPI_Count esize, MPI_Count elb,
+                                MPI_Count eextent)
+{
+    MPI_Count size = -1, lb = 1, extent = -1;
+    CHECK(MPI_SUCCESS == MPI_Type_size_c(t, &size));
+    CHECK(esize == size);
+    CHECK(MPI_SUCCESS == MPI_Type_get_extent_c(t, &lb, &extent));
+    CHECK(elb == lb);
+    CHECK(eextent == extent);
+}
+
+static void test_vector_c_bigcount(void)
+{
+    MPI_Count count = BIG + 5, blen = BIG + 6, stride = BIG + 7;
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_vector_c(count, blen, stride, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("vector_c", t, MPI_COMBINER_VECTOR, 0, 0, 3, 1);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[3] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 3, 1, ai, aa, alc, ad));
+    CHECK(count == alc[0]);
+    CHECK(blen == alc[1]);
+    CHECK(stride == alc[2]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* size = count*blen; extent spans the last block: (count-1)*stride+blen
+     * (oldextent 1).  ~4.6e18, fits in MPI_Count. */
+    check_size_extent_c(t, count * blen, 0, (count - 1) * stride + blen);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_hvector_c_bigcount(void)
+{
+    MPI_Count count = BIG + 5, blen = BIG + 6, stride = BIG + 7; /* bytes */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_hvector_c(count, blen, stride, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("hvector_c", t, MPI_COMBINER_HVECTOR, 0, 0, 3, 1);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[3] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 3, 1, ai, aa, alc, ad));
+    CHECK(count == alc[0]);
+    CHECK(blen == alc[1]);
+    CHECK(stride == alc[2]); /* byte stride survives as a large count */
+    CHECK(MPI_BYTE == ad[0]);
+
+    check_size_extent_c(t, count * blen, 0, (count - 1) * stride + blen);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_indexed_c_bigcount(void)
+{
+    MPI_Count bl[2] = {BIG + 5, 3};
+    MPI_Count disp[2] = {0, BIG + 6}; /* element units */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_indexed_c(2, bl, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("indexed_c", t, MPI_COMBINER_INDEXED, 0, 0, 5, 1);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[5] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 5, 1, ai, aa, alc, ad));
+    CHECK(2 == alc[0]);        /* count */
+    CHECK(bl[0] == alc[1]);    /* blocklengths */
+    CHECK(bl[1] == alc[2]);
+    CHECK(disp[0] == alc[3]);  /* displacements */
+    CHECK(disp[1] == alc[4]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* size = sum of blocklengths; extent spans from the lowest displacement
+     * to the highest displacement+blocklength (element units, oldextent 1). */
+    MPI_Count ub = disp[0] + bl[0];
+    if (disp[1] + bl[1] > ub) { ub = disp[1] + bl[1]; }
+    check_size_extent_c(t, bl[0] + bl[1], 0, ub);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_hindexed_c_bigcount(void)
+{
+    MPI_Count bl[2] = {BIG + 5, 3};
+    MPI_Count disp[2] = {0, BIG + 6}; /* bytes */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_create_hindexed_c(2, bl, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("hindexed_c", t, MPI_COMBINER_HINDEXED, 0, 0, 5, 1);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[5] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 5, 1, ai, aa, alc, ad));
+    CHECK(2 == alc[0]);
+    CHECK(bl[0] == alc[1]);
+    CHECK(bl[1] == alc[2]);
+    CHECK(disp[0] == alc[3]);
+    CHECK(disp[1] == alc[4]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* Byte displacements, oldextent 1: same footprint formula as indexed. */
+    MPI_Count ub = disp[0] + bl[0];
+    if (disp[1] + bl[1] > ub) { ub = disp[1] + bl[1]; }
+    check_size_extent_c(t, bl[0] + bl[1], 0, ub);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_indexed_block_c_bigcount(void)
+{
+    MPI_Count blen = BIG + 5;
+    MPI_Count disp[2] = {0, BIG + 6}; /* element units */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_indexed_block_c(2, blen, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("indexed_block_c", t, MPI_COMBINER_INDEXED_BLOCK, 0, 0, 4, 1);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[4] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 4, 1, ai, aa, alc, ad));
+    CHECK(2 == alc[0]);        /* count */
+    CHECK(blen == alc[1]);     /* blocklength */
+    CHECK(disp[0] == alc[2]);  /* displacements */
+    CHECK(disp[1] == alc[3]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* size = count*blocklength; extent spans to the farthest block end. */
+    MPI_Count ub = disp[0] + blen;
+    if (disp[1] + blen > ub) { ub = disp[1] + blen; }
+    check_size_extent_c(t, 2 * blen, 0, ub);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_hindexed_block_c_bigcount(void)
+{
+    MPI_Count blen = BIG + 5;
+    MPI_Count disp[2] = {0, BIG + 6}; /* bytes */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_hindexed_block_c(2, blen, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("hindexed_block_c", t, MPI_COMBINER_HINDEXED_BLOCK, 0, 0, 4, 1);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[4] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 4, 1, ai, aa, alc, ad));
+    CHECK(2 == alc[0]);
+    CHECK(blen == alc[1]);
+    CHECK(disp[0] == alc[2]);
+    CHECK(disp[1] == alc[3]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* Byte displacements, oldextent 1: same footprint as indexed_block. */
+    MPI_Count ub = disp[0] + blen;
+    if (disp[1] + blen > ub) { ub = disp[1] + blen; }
+    check_size_extent_c(t, 2 * blen, 0, ub);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_struct_c_bigcount(void)
+{
+    MPI_Count bl[2] = {BIG + 5, 3};
+    MPI_Count disp[2] = {0, BIG + 6}; /* bytes */
+    MPI_Datatype types[2] = {MPI_BYTE, MPI_INT};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_struct_c(2, bl, disp, types, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("struct_c", t, MPI_COMBINER_STRUCT, 0, 0, 5, 2);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[5] = {0};
+    MPI_Datatype ad[2] = {MPI_DATATYPE_NULL, MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 5, 2, ai, aa, alc, ad));
+    CHECK(2 == alc[0]);
+    CHECK(bl[0] == alc[1]);
+    CHECK(bl[1] == alc[2]);
+    CHECK(disp[0] == alc[3]);
+    CHECK(disp[1] == alc[4]);
+    CHECK(MPI_BYTE == ad[0]);
+    CHECK(MPI_INT == ad[1]);
+
+    /* size = bl0 bytes + bl1 ints.  extent = upper bound rounded up to the
+     * max member alignment (MPI 5.0 eq. 5.1); here that is alignof(int). */
+    MPI_Count esize = bl[0] * 1 + bl[1] * (MPI_Count) sizeof(int);
+    MPI_Count ub = disp[1] + bl[1] * (MPI_Count) sizeof(int); /* > disp0+bl0 */
+    MPI_Count align = (MPI_Count) _Alignof(int);
+    check_size_extent_c(t, esize, 0, ((ub + align - 1) / align) * align);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_subarray_c_bigcount(void)
+{
+    /* 2-D with size, subsize, AND start all above INT_MAX in the first
+     * dimension (start + subsize <= size keeps it legal), so the punning
+     * of the subsize and start arrays is exercised too -- not just sizes. */
+    MPI_Count sizes[2] = {2 * BIG + 100, 6};
+    MPI_Count subsizes[2] = {BIG + 5, 2};
+    MPI_Count starts[2] = {BIG + 3, 1};
+    /* Fail loudly if a future constant edit makes the subarray illegal. */
+    CHECK(starts[0] + subsizes[0] <= sizes[0]);
+    CHECK(starts[1] + subsizes[1] <= sizes[1]);
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_subarray_c(2, sizes, subsizes, starts,
+                                        MPI_ORDER_C, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    /* ndims and order are int -> integers; sizes/subsizes/starts are
+     * MPI_Count -> large counts. */
+    check_env_c("subarray_c", t, MPI_COMBINER_SUBARRAY, 2, 0, 6, 1);
+
+    int ai[2] = {0};
+    MPI_Aint aa[1];
+    MPI_Count alc[6] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 2, 0, 6, 1, ai, aa, alc, ad));
+    CHECK(2 == ai[0]);             /* ndims */
+    CHECK(MPI_ORDER_C == ai[1]);   /* order */
+    CHECK(sizes[0] == alc[0]);
+    CHECK(sizes[1] == alc[1]);
+    CHECK(subsizes[0] == alc[2]);
+    CHECK(subsizes[1] == alc[3]);
+    CHECK(starts[0] == alc[4]);
+    CHECK(starts[1] == alc[5]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* size = product of subsizes (the local block); extent = product of the
+     * full sizes (lb 0).  This is what caught the darray int-truncation bug,
+     * so subarray is checked the same way. */
+    check_size_extent_c(t, subsizes[0] * subsizes[1], 0, sizes[0] * sizes[1]);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_darray_c_bigcount(void)
+{
+    /* Single process, two dimensions, block distribution: rank 0 owns the
+     * entire (huge) global array.  Two gsizes exercise a multi-entry
+     * large-count array. */
+    MPI_Count gsizes[2] = {BIG + 5, BIG + 6};
+    int distribs[2] = {MPI_DISTRIBUTE_BLOCK, MPI_DISTRIBUTE_BLOCK};
+    int dargs[2] = {MPI_DISTRIBUTE_DFLT_DARG, MPI_DISTRIBUTE_DFLT_DARG};
+    int psizes[2] = {1, 1};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_darray_c(1, 0, 2, gsizes, distribs, dargs,
+                                      psizes, MPI_ORDER_C, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    /* All ints (size, rank, ndims, distribs[2], dargs[2], psizes[2], order)
+     * give ni = 4 + 3*ndims = 10; the gsizes are the only large counts
+     * (nlc = ndims = 2). */
+    check_env_c("darray_c", t, MPI_COMBINER_DARRAY, 10, 0, 2, 1);
+
+    int ai[10] = {0};
+    MPI_Aint aa[1];
+    MPI_Count alc[2] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 10, 0, 2, 1, ai, aa, alc, ad));
+    CHECK(1 == ai[0]);                          /* size */
+    CHECK(0 == ai[1]);                          /* rank */
+    CHECK(2 == ai[2]);                          /* ndims */
+    CHECK(MPI_DISTRIBUTE_BLOCK == ai[3]);       /* distribs[0] */
+    CHECK(MPI_DISTRIBUTE_BLOCK == ai[4]);       /* distribs[1] */
+    CHECK(MPI_DISTRIBUTE_DFLT_DARG == ai[5]);   /* dargs[0] */
+    CHECK(MPI_DISTRIBUTE_DFLT_DARG == ai[6]);   /* dargs[1] */
+    CHECK(1 == ai[7]);                          /* psizes[0] */
+    CHECK(1 == ai[8]);                          /* psizes[1] */
+    CHECK(MPI_ORDER_C == ai[9]);                /* order */
+    CHECK(gsizes[0] == alc[0]);
+    CHECK(gsizes[1] == alc[1]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* One process owns the whole array, so both the size (local bytes) and
+     * the extent equal the product of the gsizes.  Asserting size here is
+     * what catches the block()/cyclic() int-truncation bug. */
+    check_size_extent_c(t, gsizes[0] * gsizes[1], 0, gsizes[0] * gsizes[1]);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_darray_cyclic_c_bigcount(void)
+{
+    /* CYCLIC distribution drives the cyclic() helper -- a different local-size
+     * computation from block() -- which also widened to 64-bit.  One process
+     * owns the whole (huge) global array. */
+    MPI_Count gsizes[1] = {BIG + 5};
+    int distribs[1] = {MPI_DISTRIBUTE_CYCLIC};
+    int dargs[1] = {MPI_DISTRIBUTE_DFLT_DARG};
+    int psizes[1] = {1};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_darray_c(1, 0, 1, gsizes, distribs, dargs, psizes,
+                                      MPI_ORDER_C, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("darray_cyclic_c", t, MPI_COMBINER_DARRAY, 7, 0, 1, 1);
+
+    /* Local size == whole array (one process); gsize survives cyclic(). */
+    check_size_extent_c(t, gsizes[0], 0, gsizes[0]);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_darray_multiproc_c_bigcount(void)
+{
+    /* Two processes, query rank 1: blksize = ceil(gsize/2) and the rank*blksize
+     * start offset both exceed INT_MAX, exercising the 64-bit products in
+     * block() that the single-process darray tests (rank 0, nprocs 1) never
+     * reach -- with int arithmetic those products would overflow. */
+    MPI_Count gsizes[1] = {4 * BIG};
+    int distribs[1] = {MPI_DISTRIBUTE_BLOCK};
+    int dargs[1] = {MPI_DISTRIBUTE_DFLT_DARG};
+    int psizes[1] = {2};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_darray_c(2, 1, 1, gsizes, distribs, dargs, psizes,
+                                      MPI_ORDER_C, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("darray_2proc_c", t, MPI_COMBINER_DARRAY, 7, 0, 1, 1);
+
+    /* BLOCK over 2 ranks: blksize = 2*BIG; rank 1 owns the upper 2*BIG
+     * elements; the type extent spans the full global array (4*BIG). */
+    check_size_extent_c(t, 2 * BIG, 0, 4 * BIG);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_darray_blockcyclic_c_bigcount(void)
+{
+    /* CYCLIC with an explicit block size > 1 and a gsize not divisible by
+     * nprocs*blksize forces rem != 0, exercising cyclic()'s trailing-struct
+     * branch (blklens[1] = rem, disps[1] = count*stride) with count*stride
+     * above INT_MAX -- untested by the DFLT_DARG (blksize 1) cyclic case. */
+    MPI_Count gsizes[1] = {BIG + 7}; /* not a multiple of 3 */
+    int distribs[1] = {MPI_DISTRIBUTE_CYCLIC};
+    int dargs[1] = {3};
+    int psizes[1] = {1};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_darray_c(1, 0, 1, gsizes, distribs, dargs, psizes,
+                                      MPI_ORDER_C, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    check_env_c("darray_blkcyc_c", t, MPI_COMBINER_DARRAY, 7, 0, 1, 1);
+
+    /* Single process owns everything: size == extent == gsize. */
+    check_size_extent_c(t, gsizes[0], 0, gsizes[0]);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_resized_c_bigcount(void)
+{
+    MPI_Count lb = BIG + 5, extent = BIG + 6;
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_create_resized_c(MPI_BYTE, lb, extent, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    /* MPI 5.0 sec 19.2: MPI_Type_create_resized_c types lb and extent as
+     * MPI_Count (not MPI_Aint), so -- exactly as for every other "_c"
+     * constructor above -- MPI_Type_get_contents_c must return them in
+     * array_of_large_counts with num_addresses == 0. */
+    check_env_c("resized_c", t, MPI_COMBINER_RESIZED, 0, 0, 2, 1);
+
+    int ai[1];
+    MPI_Aint aa[1];
+    MPI_Count alc[2] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, 0, 0, 2, 1, ai, aa, alc, ad));
+    CHECK(lb == alc[0]);
+    CHECK(extent == alc[1]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* Resizing does not change the data size (one MPI_BYTE); the requested
+     * lb and extent are reported back by get_extent_c. */
+    check_size_extent_c(t, 1, lb, extent);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+
+    /* A negative lb above INT_MAX in magnitude must also round-trip through
+     * the large-count array on the public _c path (signed value preserved). */
+    MPI_Count nlb = -(BIG + 5), next = BIG + 6;
+    MPI_Datatype t2 = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_create_resized_c(MPI_BYTE, nlb, next, &t2));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t2));
+    check_env_c("resized_c(neg)", t2, MPI_COMBINER_RESIZED, 0, 0, 2, 1);
+    MPI_Count alc2[2] = {0};
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t2, 0, 0, 2, 1, ai, aa, alc2, ad));
+    CHECK(nlb == alc2[0]);
+    CHECK(next == alc2[1]);
+    check_size_extent_c(t2, 1, nlb, next);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t2));
+}
+
+/* ===================================================================
+ * (E) Classic (small-count, int) decode coverage.
+ *
+ * The (D) tests drive only the "_c" interface, which stores every count
+ * and byte displacement as a large count (na == 0).  The classic
+ * interface is a *separate* code path (the "#else" branch of each
+ * binding): block lengths and element counts land in array_of_integers,
+ * while byte displacements/strides (MPI_Aint) land in array_of_addresses.
+ * Nothing else in test/datatype exercises get_envelope/get_contents, so
+ * these build each constructor with the classic int API and small values
+ * and assert the full MPI 5.0 sec 5.1.13 classic decode -- combiner,
+ * (ni, na, nd), and the value in every slot.
+ * =================================================================== */
+
+static void check_env_classic(const char *label, MPI_Datatype t,
+                              int expect_combiner, int eni, int ena, int end)
+{
+    int ni = -1, na = -1, nd = -1, combiner = -1;
+    CHECK(MPI_SUCCESS == MPI_Type_get_envelope(t, &ni, &na, &nd, &combiner));
+    printf("  %-15s combiner=%2d ni=%d na=%d nd=%d\n", label, combiner, ni, na,
+           nd);
+    fflush(stdout);
+    CHECK(expect_combiner == combiner);
+    CHECK(eni == ni);
+    CHECK(ena == na);
+    CHECK(end == nd);
+}
+
+/* Classic-API footprint check: size, lower bound, and extent. */
+static void check_size_extent_classic(MPI_Datatype t, int esize, MPI_Aint elb,
+                                      MPI_Aint eextent)
+{
+    int size = -1;
+    CHECK(MPI_SUCCESS == MPI_Type_size(t, &size));
+    CHECK(esize == size);
+    MPI_Aint lb = 1, extent = -1;
+    CHECK(MPI_SUCCESS == MPI_Type_get_extent(t, &lb, &extent));
+    CHECK(elb == lb);
+    CHECK(eextent == extent);
+}
+
+static void test_contiguous_classic(void)
+{
+    int count = 7;
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_contiguous(count, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("contiguous", t, MPI_COMBINER_CONTIGUOUS, 1, 0, 1);
+
+    int ai[1] = {0};
+    MPI_Aint aa[1];
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 1, 0, 1, ai, aa, ad));
+    CHECK(count == ai[0]);
+    CHECK(MPI_BYTE == ad[0]);
+    check_size_extent_classic(t, count, 0, count);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_vector_classic(void)
+{
+    int count = 4, blen = 3, stride = 5;
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_vector(count, blen, stride, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("vector", t, MPI_COMBINER_VECTOR, 3, 0, 1);
+
+    int ai[3] = {0};
+    MPI_Aint aa[1];
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 3, 0, 1, ai, aa, ad));
+    CHECK(count == ai[0]);
+    CHECK(blen == ai[1]);
+    CHECK(stride == ai[2]);
+    CHECK(MPI_BYTE == ad[0]);
+    check_size_extent_classic(t, count * blen, 0, (count - 1) * stride + blen);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_hvector_classic(void)
+{
+    int count = 4, blen = 3;
+    MPI_Aint stride = 64; /* bytes -> array_of_addresses */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_hvector(count, blen, stride, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("hvector", t, MPI_COMBINER_HVECTOR, 2, 1, 1);
+
+    int ai[2] = {0};
+    MPI_Aint aa[1] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 2, 1, 1, ai, aa, ad));
+    CHECK(count == ai[0]);
+    CHECK(blen == ai[1]);
+    CHECK(stride == aa[0]);
+    CHECK(MPI_BYTE == ad[0]);
+    check_size_extent_classic(t, count * blen, 0, (count - 1) * stride + blen);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_indexed_classic(void)
+{
+    int bl[2] = {5, 3};
+    int disp[2] = {0, 8}; /* element units */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_indexed(2, bl, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("indexed", t, MPI_COMBINER_INDEXED, 5, 0, 1);
+
+    int ai[5] = {0};
+    MPI_Aint aa[1];
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 5, 0, 1, ai, aa, ad));
+    CHECK(2 == ai[0]);        /* count */
+    CHECK(bl[0] == ai[1]);
+    CHECK(bl[1] == ai[2]);
+    CHECK(disp[0] == ai[3]);  /* element displacements stay in integers */
+    CHECK(disp[1] == ai[4]);
+    CHECK(MPI_BYTE == ad[0]);
+    {
+        MPI_Aint ub = disp[0] + bl[0];
+        if (disp[1] + bl[1] > ub) { ub = disp[1] + bl[1]; }
+        check_size_extent_classic(t, bl[0] + bl[1], 0, ub);
+    }
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_hindexed_classic(void)
+{
+    int bl[2] = {5, 3};
+    MPI_Aint disp[2] = {0, 64}; /* bytes -> array_of_addresses */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_create_hindexed(2, bl, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("hindexed", t, MPI_COMBINER_HINDEXED, 3, 2, 1);
+
+    int ai[3] = {0};
+    MPI_Aint aa[2] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 3, 2, 1, ai, aa, ad));
+    CHECK(2 == ai[0]);
+    CHECK(bl[0] == ai[1]);
+    CHECK(bl[1] == ai[2]);
+    CHECK(disp[0] == aa[0]);
+    CHECK(disp[1] == aa[1]);
+    CHECK(MPI_BYTE == ad[0]);
+    {
+        MPI_Aint ub = disp[0] + bl[0];
+        if (disp[1] + bl[1] > ub) { ub = disp[1] + bl[1]; }
+        check_size_extent_classic(t, bl[0] + bl[1], 0, ub);
+    }
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_indexed_block_classic(void)
+{
+    int blen = 5;
+    int disp[2] = {0, 8};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_indexed_block(2, blen, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("indexed_block", t, MPI_COMBINER_INDEXED_BLOCK, 4, 0, 1);
+
+    int ai[4] = {0};
+    MPI_Aint aa[1];
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 4, 0, 1, ai, aa, ad));
+    CHECK(2 == ai[0]);        /* count */
+    CHECK(blen == ai[1]);     /* blocklength */
+    CHECK(disp[0] == ai[2]);
+    CHECK(disp[1] == ai[3]);
+    CHECK(MPI_BYTE == ad[0]);
+    {
+        MPI_Aint ub = disp[0] + blen;
+        if (disp[1] + blen > ub) { ub = disp[1] + blen; }
+        check_size_extent_classic(t, 2 * blen, 0, ub);
+    }
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_hindexed_block_classic(void)
+{
+    int blen = 5;
+    MPI_Aint disp[2] = {0, 64};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_hindexed_block(2, blen, disp, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("hindexed_block", t, MPI_COMBINER_HINDEXED_BLOCK, 2, 2, 1);
+
+    int ai[2] = {0};
+    MPI_Aint aa[2] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 2, 2, 1, ai, aa, ad));
+    CHECK(2 == ai[0]);
+    CHECK(blen == ai[1]);
+    CHECK(disp[0] == aa[0]);
+    CHECK(disp[1] == aa[1]);
+    CHECK(MPI_BYTE == ad[0]);
+    {
+        MPI_Aint ub = disp[0] + blen;
+        if (disp[1] + blen > ub) { ub = disp[1] + blen; }
+        check_size_extent_classic(t, 2 * blen, 0, ub);
+    }
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_struct_classic(void)
+{
+    int bl[2] = {5, 3};
+    MPI_Aint disp[2] = {0, 64};
+    MPI_Datatype types[2] = {MPI_BYTE, MPI_INT};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_create_struct(2, bl, disp, types, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("struct", t, MPI_COMBINER_STRUCT, 3, 2, 2);
+
+    int ai[3] = {0};
+    MPI_Aint aa[2] = {0};
+    MPI_Datatype ad[2] = {MPI_DATATYPE_NULL, MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 3, 2, 2, ai, aa, ad));
+    CHECK(2 == ai[0]);
+    CHECK(bl[0] == ai[1]);
+    CHECK(bl[1] == ai[2]);
+    CHECK(disp[0] == aa[0]);
+    CHECK(disp[1] == aa[1]);
+    CHECK(MPI_BYTE == ad[0]);
+    CHECK(MPI_INT == ad[1]);
+    {
+        MPI_Aint ub = disp[1] + bl[1] * (MPI_Aint) sizeof(int); /* > disp0+bl0 */
+        MPI_Aint align = (MPI_Aint) _Alignof(int);
+        check_size_extent_classic(t, bl[0] * 1 + bl[1] * (int) sizeof(int), 0,
+                                  ((ub + align - 1) / align) * align);
+    }
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_subarray_classic(void)
+{
+    int sizes[2] = {6, 4};
+    int subsizes[2] = {2, 2};
+    int starts[2] = {1, 1};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_subarray(2, sizes, subsizes, starts, MPI_ORDER_C,
+                                      MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("subarray", t, MPI_COMBINER_SUBARRAY, 8, 0, 1);
+
+    int ai[8] = {0};
+    MPI_Aint aa[1];
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 8, 0, 1, ai, aa, ad));
+    CHECK(2 == ai[0]); /* ndims */
+    CHECK(sizes[0] == ai[1]);
+    CHECK(sizes[1] == ai[2]);
+    CHECK(subsizes[0] == ai[3]);
+    CHECK(subsizes[1] == ai[4]);
+    CHECK(starts[0] == ai[5]);
+    CHECK(starts[1] == ai[6]);
+    CHECK(MPI_ORDER_C == ai[7]); /* order */
+    CHECK(MPI_BYTE == ad[0]);
+    check_size_extent_classic(t, subsizes[0] * subsizes[1], 0,
+                              sizes[0] * sizes[1]);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_darray_classic(void)
+{
+    int gsizes[1] = {12};
+    int distribs[1] = {MPI_DISTRIBUTE_BLOCK};
+    int dargs[1] = {MPI_DISTRIBUTE_DFLT_DARG};
+    int psizes[1] = {1};
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_darray(1, 0, 1, gsizes, distribs, dargs, psizes,
+                                    MPI_ORDER_C, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+    check_env_classic("darray", t, MPI_COMBINER_DARRAY, 8, 0, 1);
+
+    int ai[8] = {0};
+    MPI_Aint aa[1];
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 8, 0, 1, ai, aa, ad));
+    CHECK(1 == ai[0]);                        /* size */
+    CHECK(0 == ai[1]);                        /* rank */
+    CHECK(1 == ai[2]);                        /* ndims */
+    CHECK(gsizes[0] == ai[3]);
+    CHECK(MPI_DISTRIBUTE_BLOCK == ai[4]);
+    CHECK(MPI_DISTRIBUTE_DFLT_DARG == ai[5]);
+    CHECK(1 == ai[6]);                        /* psizes */
+    CHECK(MPI_ORDER_C == ai[7]);              /* order */
+    CHECK(MPI_BYTE == ad[0]);
+    check_size_extent_classic(t, gsizes[0], 0, gsizes[0]);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+/* Regression guard for the classic (non-_c) resized path, which shares the
+ * binding fixed alongside the _c path: lb/extent are MPI_Aint and must still
+ * decode into array_of_addresses (na=2, no large counts). */
+static void test_resized_classic(void)
+{
+    MPI_Aint lb = -3, extent = 4096;
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS == MPI_Type_create_resized(MPI_BYTE, lb, extent, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    int ni = -1, na = -1, nd = -1, combiner = -1;
+    CHECK(MPI_SUCCESS == MPI_Type_get_envelope(t, &ni, &na, &nd, &combiner));
+    CHECK(MPI_COMBINER_RESIZED == combiner);
+    CHECK(0 == ni);
+    CHECK(2 == na);
+    CHECK(1 == nd);
+
+    int ai[1];
+    MPI_Aint aa[2] = {0};
+    MPI_Datatype ad[1] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS == MPI_Type_get_contents(t, 0, 2, 1, ai, aa, ad));
+    CHECK(lb == aa[0]);
+    CHECK(extent == aa[1]);
+    CHECK(MPI_BYTE == ad[0]);
+
+    /* Resizing keeps the data size (one MPI_BYTE) but applies lb/extent. */
+    check_size_extent_classic(t, 1, lb, extent);
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+static void test_constructors_classic(void)
+{
+    test_contiguous_classic();
+    test_vector_classic();
+    test_hvector_classic();
+    test_indexed_classic();
+    test_hindexed_classic();
+    test_indexed_block_classic();
+    test_hindexed_block_classic();
+    test_struct_classic();
+    test_subarray_classic();
+    test_darray_classic();
+    test_resized_classic();
+}
+
+static void test_constructors_c_bigcount(void)
+{
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped big-count constructors)\n");
+        return;
+    }
+    test_vector_c_bigcount();
+    test_hvector_c_bigcount();
+    test_indexed_c_bigcount();
+    test_hindexed_c_bigcount();
+    test_indexed_block_c_bigcount();
+    test_hindexed_block_c_bigcount();
+    test_struct_c_bigcount();
+    test_subarray_c_bigcount();
+    test_darray_c_bigcount();
+    test_darray_cyclic_c_bigcount();
+    test_darray_multiproc_c_bigcount();
+    test_darray_blockcyclic_c_bigcount();
+    test_resized_c_bigcount();
+}
+
+/* (F) get_elements with an element count above INT_MAX.  We seed the status
+ * with the public MPI_Status_set_elements_c (no multi-GB transfer needed)
+ * so the byte->element division is genuinely exercised by the binding. */
+static void test_get_elements_bigcount(void)
+{
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped)\n");
+        return;
+    }
+
+    MPI_Status status;
+    memset(&status, 0, sizeof(status)); /* defined fields for memchecker builds */
+
+    /* MPI_BYTE: element count == byte count. */
+    MPI_Count nbytes = (MPI_Count) INT_MAX + 100;
+    CHECK(MPI_SUCCESS == MPI_Status_set_elements_c(&status, MPI_BYTE, nbytes));
+
+    MPI_Count ec = -1;
+    CHECK(MPI_SUCCESS == MPI_Get_elements_c(&status, MPI_BYTE, &ec));
+    CHECK(nbytes == ec);
+
+    /* The classic int interface cannot represent > INT_MAX elements, so it
+     * must return MPI_UNDEFINED (MPI 3.0). */
+    int eci = 0;
+    CHECK(MPI_SUCCESS == MPI_Get_elements(&status, MPI_BYTE, &eci));
+    CHECK(MPI_UNDEFINED == eci);
+
+    /* MPI_INT: seed the element count and let the binding divide the byte
+     * count back out -- a real round-trip, with a result above INT_MAX. */
+    MPI_Count nints = (MPI_Count) INT_MAX + 99;
+    CHECK(MPI_SUCCESS == MPI_Status_set_elements_c(&status, MPI_INT, nints));
+    ec = -1;
+    CHECK(MPI_SUCCESS == MPI_Get_elements_c(&status, MPI_INT, &ec));
+    CHECK(nints == ec);
+
+    /* A byte count that is NOT an integral number of MPI_INT elements must
+     * decode to MPI_UNDEFINED (MPI 5.0 sec 5.1.11).  There is no public way
+     * to seed a partial byte count, so set the internal _ucount field
+     * directly for just this case. */
+    status._ucount = (size_t) nints * sizeof(int) + 1;
+    ec = 0;
+    CHECK(MPI_SUCCESS == MPI_Get_elements_c(&status, MPI_INT, &ec));
+    CHECK(MPI_UNDEFINED == ec);
+
+    printf("  get_elements_c: MPI_BYTE/%lld -> %lld, MPI_INT -> %lld; "
+           "classic int & partial -> MPI_UNDEFINED\n",
+           (long long) nbytes, (long long) nbytes, (long long) nints);
+    fflush(stdout);
+}
+
+/* #14055 over-read check, factored so it can run against more than the
+ * struct combiner in test_get_contents_c_oversized: with output arrays
+ * larger than the envelope, get_contents_c must fill only the real
+ * constituent datatypes and leave the surplus slots untouched. */
+static void check_no_overread_c(const char *label, MPI_Datatype t)
+{
+    enum { SLACK = 8 };
+    MPI_Count ni = -1, na = -1, nlc = -1, nd = -1;
+    int combiner = -1;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_envelope_c(t, &ni, &na, &nlc, &nd, &combiner));
+    if (ni < 0 || na < 0 || nlc < 0 || nd < 0) {
+        CHECK(false);
+        return;
+    }
+    int *ai = calloc((size_t) ni + SLACK, sizeof(int));
+    MPI_Aint *aa = calloc((size_t) na + SLACK, sizeof(MPI_Aint));
+    MPI_Count *alc = calloc((size_t) nlc + SLACK, sizeof(MPI_Count));
+    MPI_Datatype *ad = malloc(((size_t) nd + SLACK) * sizeof(MPI_Datatype));
+    CHECK(NULL != ai && NULL != aa && NULL != alc && NULL != ad);
+    if (NULL == ai || NULL == aa || NULL == alc || NULL == ad) {
+        free(ai); free(aa); free(alc); free(ad);
+        return;
+    }
+    for (size_t i = 0; i < (size_t) nd + SLACK; ++i) {
+        ad[i] = POISON;
+    }
+    CHECK(MPI_SUCCESS
+          == MPI_Type_get_contents_c(t, ni + SLACK, na + SLACK, nlc + SLACK,
+                                     nd + SLACK, ai, aa, alc, ad));
+    for (size_t i = 0; i < (size_t) nd; ++i) {
+        CHECK(POISON != ad[i]); /* real constituents filled in */
+    }
+    for (size_t i = (size_t) nd; i < (size_t) nd + SLACK; ++i) {
+        CHECK(POISON == ad[i]); /* surplus slots untouched */
+    }
+    printf("  no-overread: %-16s nd=%lld\n", label, (long long) nd);
+    fflush(stdout);
+    free(ai); free(aa); free(alc); free(ad);
+}
+
+static void test_oversized_more_combiners(void)
+{
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped)\n");
+        return;
+    }
+    /* hindexed_block and resized are the combiners whose large-count decode
+     * this work changed; verify their get_contents_c has no over-read too. */
+    MPI_Count blen = BIG + 5;
+    MPI_Count disp[2] = {0, BIG + 6};
+    MPI_Datatype hib = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_hindexed_block_c(2, blen, disp, MPI_BYTE, &hib));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&hib));
+    check_no_overread_c("hindexed_block_c", hib);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&hib));
+
+    MPI_Datatype rsz = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_create_resized_c(MPI_BYTE, BIG + 5, BIG + 6, &rsz));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&rsz));
+    check_no_overread_c("resized_c", rsz);
+    CHECK(MPI_SUCCESS == MPI_Type_free(&rsz));
+}
+
+/* A datatype built with a large count cannot be decoded through the classic
+ * (non-_c) envelope/contents calls: MPI 5.0 sec 5.1.13 requires MPI_ERR_TYPE
+ * rather than silent truncation.  This is the exact mismatch a user hits when
+ * they build with MPI_Type_*_c and query with the classic API. */
+static void test_classic_rejects_bigcount(void)
+{
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped)\n");
+        return;
+    }
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    CHECK(MPI_SUCCESS
+          == MPI_Type_contiguous_c((MPI_Count) INT_MAX + 7, MPI_BYTE, &t));
+    CHECK(MPI_SUCCESS == MPI_Type_commit(&t));
+
+    /* Both classic decode entry points must fail (num_large_counts > 0). */
+    int ni = -1, na = -1, nd = -1, combiner = -1;
+    CHECK(MPI_SUCCESS != MPI_Type_get_envelope(t, &ni, &na, &nd, &combiner));
+
+    int ai[4] = {0};
+    MPI_Aint aa[4] = {0};
+    MPI_Datatype ad[4] = {MPI_DATATYPE_NULL};
+    CHECK(MPI_SUCCESS != MPI_Type_get_contents(t, 4, 4, 4, ai, aa, ad));
+
+    CHECK(MPI_SUCCESS == MPI_Type_free(&t));
+}
+
+int main(int argc, char *argv[])
+{
+    int rc = MPI_Init(&argc, &argv);
+    if (MPI_SUCCESS != rc) {
+        fprintf(stderr, "MPI_Init failed (rc=%d)\n", rc);
+        return 1;
+    }
+    /* Report MPI errors as return codes so a single failing call records a
+     * CHECK failure and the test keeps running, instead of aborting the
+     * whole program on the first problem. */
+    MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
+
+    printf("--- MPI_Type_contiguous_c (count > INT_MAX) ---\n");
+    test_contiguous_c_bigcount();
+    printf("--- MPI_Type_get_contents_c oversized arrays (#14055, _c) ---\n");
+    test_get_contents_c_oversized();
+    printf("--- MPI_Type_get_contents oversized arrays (#14055, classic) ---\n");
+    test_get_contents_oversized();
+    printf("--- get_contents_c oversized arrays, more combiners (#14055) ---\n");
+    test_oversized_more_combiners();
+    printf("--- classic get_envelope/get_contents reject a _c big-count type ---\n");
+    test_classic_rejects_bigcount();
+    printf("--- derived-type constructors (classic) with small counts ---\n");
+    test_constructors_classic();
+    printf("--- derived-type constructors (_c) with args > INT_MAX ---\n");
+    test_constructors_c_bigcount();
+    printf("--- MPI_Get_elements[_c] (elements > INT_MAX) ---\n");
+    test_get_elements_bigcount();
+
+    MPI_Finalize();
+
+    if (0 == failures) {
+        printf("SUCCESS: all MPI big-count datatype checks passed\n");
+        return 0;
+    }
+    fprintf(stderr, "FAILURE: %d MPI big-count datatype check(s) failed\n",
+            failures);
+    return 1;
+}
diff --git a/ompi/test/datatype/ompi_datatype_bigcount.c b/ompi/test/datatype/ompi_datatype_bigcount.c
new file mode 100644
index 00000000000..6b487821234
--- /dev/null
+++ b/ompi/test/datatype/ompi_datatype_bigcount.c
@@ -0,0 +1,734 @@
+/* -*- Mode: C; c-basic-offset:4 ; -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/**
+ * OMPI-layer "big count" datatype tests, exercised through the internal
+ * ompi_datatype_* routines.
+ *
+ * This is a singleton test that initializes only the OMPI datatype
+ * engine (opal_init + ompi_datatype_init) -- it does NOT call MPI_Init,
+ * matching every other auto-run test in test/datatype.  The public MPI
+ * C-binding wrappers (MPI_Type_*_c, MPI_Type_get_contents[_c]) are
+ * exercised separately by mpi_datatype_bigcount.c, which does call
+ * MPI_Init.
+ *
+ * Coverage:
+ *   1. ompi_datatype_create_contiguous() with a count above INT_MAX:
+ *      the resulting size/extent must be computed in 64 bits.
+ *   2. ompi_datatype_set_args()/get_args() round-trip with an
+ *      above-INT_MAX count, modeled exactly on the big-count branch of
+ *      the generated type_contiguous binding (counts stored in the
+ *      "large" array; ci=0, cl=1).  Verifies the int-vs-MPI_Count
+ *      type-punning preserves the value.
+ *   3. The get_args() invariant that the #14055 get_contents fix relies
+ *      on: when handed an oversized output array, get_args fills only
+ *      the real number of constituent entries and never touches the
+ *      caller's surplus slots.
+ *   4. ompi_datatype_match_size() (#14057): a (typeclass, size) request
+ *      returns only a basic scalar predefined type, and fails cleanly
+ *      otherwise.
+ *   5. Pack/unpack of the datatype description for above-INT_MAX types:
+ *      ompi_datatype_get_pack_description() followed by
+ *      ompi_datatype_create_from_packed_description() must rebuild an
+ *      equivalent type.  This is the only path that exercises the
+ *      bigcount ("l != NULL") branches of __ompi_datatype_create_from_args
+ *      and the size_t count array in the packed description -- the code
+ *      that one-sided, MPI-IO, and heterogeneous transfers rely on.
+ */
+
+#include "ompi_config.h"
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <mpi.h>
+
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/proc/proc.h"
+#include "ompi/util/count_disp_array.h"
+#include "opal/datatype/opal_datatype.h"
+#include "opal/runtime/opal.h"
+
+static int failures = 0;
+
+#define CHECK(cond)                                                       \
+    do {                                                                  \
+        if (!(cond)) {                                                    \
+            fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__,       \
+                    #cond);                                               \
+            ++failures;                                                   \
+        }                                                                 \
+    } while (0)
+
+/* Recognizable non-NULL garbage handle used to poison surplus output
+ * slots (named to match POISON in mpi_datatype_bigcount.c). */
+static ompi_datatype_t *const POISON = (ompi_datatype_t *) (intptr_t) 0xdeadbeef;
+
+static bool have_64bit_counts(void)
+{
+    return 8 == sizeof(size_t);
+}
+
+/* (1) Engine size/extent for a contiguous type whose count exceeds
+ * INT_MAX, built through the OMPI wrapper. */
+static void test_create_contiguous_bigcount(void)
+{
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped)\n");
+        return;
+    }
+
+    size_t count = (size_t) INT_MAX + 4096;
+    ompi_datatype_t *type = NULL;
+    int rc = ompi_datatype_create_contiguous(count, &ompi_mpi_byte.dt, &type);
+    CHECK(OMPI_SUCCESS == rc);
+    CHECK(NULL != type);
+    if (NULL == type) {
+        return;
+    }
+    ompi_datatype_commit(&type);
+
+    size_t size = 0;
+    ompi_datatype_type_size(type, &size);
+    CHECK(count == size); /* MPI_BYTE has size 1 */
+
+    ptrdiff_t extent = 0;
+    ompi_datatype_type_extent(type, &extent);
+    CHECK((ptrdiff_t) count == extent);
+
+    printf("  contiguous(%" PRIuPTR " x MPI_BYTE): size=%" PRIuPTR "\n",
+           (uintptr_t) count, (uintptr_t) size);
+
+    ompi_datatype_destroy(&type);
+}
+
+/* (2) + (3) set_args/get_args type-punning round-trip and the
+ * oversized-output-array invariant.  We store the args exactly as the
+ * big-count type_contiguous binding does. */
+static void test_set_get_args_bigcount(void)
+{
+    if (!have_64bit_counts()) {
+        return;
+    }
+
+    size_t count = (size_t) INT_MAX + 12345;
+    ompi_datatype_t *type = NULL;
+    int rc = ompi_datatype_create_contiguous(count, &ompi_mpi_byte.dt, &type);
+    CHECK(OMPI_SUCCESS == rc);
+    if (NULL == type) {
+        return;
+    }
+
+    /* Mirror type_contiguous.c.in's OMPI_BIGCOUNT_SRC branch: a single
+     * MPI_Count count (8 bytes => 64-bit count array) goes into the
+     * "large" slot, so ci=0, cl=1. */
+    MPI_Count cnt = (MPI_Count) count;
+    ompi_count_array_t a_i[1] = {OMPI_COUNT_ARRAY_CREATE(&cnt)};
+    ompi_datatype_t *oldtype = &ompi_mpi_byte.dt;
+    CHECK(ompi_count_array_is_64bit(a_i[0]));
+
+    rc = ompi_datatype_set_args(type, 0, 1, a_i, 0, OMPI_DISP_ARRAY_NULL, 1,
+                                &oldtype, MPI_COMBINER_CONTIGUOUS);
+    CHECK(OMPI_SUCCESS == rc);
+
+    /* which=0: retrieve the real counts and combiner. */
+    size_t ci = 0, cl = 0, ca = 0, cd = 0;
+    int32_t combiner = -1;
+    rc = ompi_datatype_get_args(type, 0, &ci, NULL, &cl, NULL, &ca, NULL, &cd,
+                                NULL, &combiner);
+    CHECK(OMPI_SUCCESS == rc);
+    CHECK(MPI_COMBINER_CONTIGUOUS == combiner);
+    CHECK(0 == ci);
+    CHECK(1 == cl);
+    CHECK(0 == ca);
+    CHECK(1 == cd);
+
+    /* which=1: retrieve the values; the above-INT_MAX count must come
+     * back undamaged through the large (MPI_Count) array. */
+    MPI_Count lout[1] = {0};
+    ompi_datatype_t *dout[1] = {NULL};
+    rc = ompi_datatype_get_args(type, 1, &ci, NULL, &cl, lout, &ca, NULL, &cd,
+                                dout, NULL);
+    CHECK(OMPI_SUCCESS == rc);
+    CHECK((MPI_Count) count == lout[0]);
+    CHECK(&ompi_mpi_byte.dt == dout[0]);
+
+    /* (3) Oversized output array: ask get_args to fill a datatype array
+     * far larger than the single real constituent.  This is the legal
+     * usage (max_datatypes discovered via get_envelope may exceed the
+     * real count) that crashed MPI_Type_get_contents before #14055.  At
+     * this layer the invariant is: only the first cd entries are
+     * written; the surplus poisoned slots are left untouched. */
+    enum { SLACK = 8 };
+    enum { LPOISON = -424242 }; /* sentinel for surplus large-count slots */
+    ompi_datatype_t *big_d[1 + SLACK];
+    MPI_Count lbig[1 + SLACK];
+    for (int i = 0; i < 1 + SLACK; ++i) {
+        big_d[i] = POISON;
+        lbig[i] = LPOISON;
+    }
+    size_t cap_ci = 0, cap_cl = (size_t) 1 + SLACK, cap_ca = 0,
+           cap_cd = (size_t) 1 + SLACK;
+    rc = ompi_datatype_get_args(type, 1, &cap_ci, NULL, &cap_cl, lbig, &cap_ca,
+                                NULL, &cap_cd, big_d, NULL);
+    CHECK(OMPI_SUCCESS == rc);
+    CHECK(&ompi_mpi_byte.dt == big_d[0]);
+    CHECK((MPI_Count) count == lbig[0]);
+    /* Both the datatype and large-count surplus slots must be untouched. */
+    for (int i = 1; i < 1 + SLACK; ++i) {
+        CHECK(POISON == big_d[i]);
+        CHECK((MPI_Count) LPOISON == lbig[i]);
+    }
+
+    ompi_datatype_destroy(&type);
+}
+
+/* (4) match_size (#14057): only basic scalar predefined types may be
+ * returned; size 0 (and any request with no scalar match) must fail. */
+static void check_match(uint16_t datakind, size_t size, bool expect_match)
+{
+    /* On no match, ompi_datatype_match_size() returns the sentinel
+     * &ompi_mpi_datatype_null.dt (which MPI_Type_match_size turns into
+     * MPI_ERR_ARG) -- it does not return NULL. */
+    const ompi_datatype_t *none = &ompi_mpi_datatype_null.dt;
+    const ompi_datatype_t *dt =
+        ompi_datatype_match_size(size, datakind, OMPI_DATATYPE_FLAG_DATA_C);
+    if (!expect_match) {
+        CHECK(none == dt);
+        return;
+    }
+    CHECK(NULL != dt && none != dt);
+    if (NULL == dt || none == dt) {
+        return;
+    }
+    /* Must be a basic scalar type of exactly the requested size and the
+     * requested language/kind -- never a composite (e.g. a paired type)
+     * and never an unavailable size-0 type. */
+    CHECK(OPAL_DATATYPE_FLAG_BASIC
+          == (dt->super.flags & OPAL_DATATYPE_FLAG_BASIC));
+    CHECK(size == dt->super.size);
+    CHECK(OMPI_DATATYPE_FLAG_DATA_C
+          == (dt->super.flags & OMPI_DATATYPE_FLAG_DATA_LANGUAGE));
+    CHECK(datakind == (dt->super.flags & OMPI_DATATYPE_FLAG_DATA_TYPE));
+}
+
+static void test_match_size_basic_only(void)
+{
+    /* C float scalars always exist regardless of Fortran availability. */
+    check_match(OMPI_DATATYPE_FLAG_DATA_FLOAT, sizeof(float), true);
+    check_match(OMPI_DATATYPE_FLAG_DATA_FLOAT, sizeof(double), true);
+    check_match(OMPI_DATATYPE_FLAG_DATA_INT, sizeof(int), true);
+
+    /* A size-0 request must never succeed (it previously could return an
+     * unavailable predefined type). */
+    check_match(OMPI_DATATYPE_FLAG_DATA_FLOAT, 0, false);
+    check_match(OMPI_DATATYPE_FLAG_DATA_INT, 0, false);
+
+    /* A wildly unlikely size has no basic scalar match and must fail
+     * rather than fall through to a composite. */
+    check_match(OMPI_DATATYPE_FLAG_DATA_FLOAT, 7, false);
+}
+
+/* (5) Pack the description of a committed bigcount type and rebuild it
+ * from the packed bytes, then verify the rebuilt type is equivalent.
+ * Rebuilding runs __ompi_datatype_create_from_args, whose bigcount
+ * branches (l != NULL) are otherwise untested. */
+static void pack_unpack_check(const char *label, ompi_datatype_t *type)
+{
+    /* A 0 length is the documented upstream failure return; treat it as the
+     * real failure rather than letting malloc(0) muddy the diagnostic. */
+    size_t plen = ompi_datatype_pack_description_length(type);
+    CHECK(plen > 0);
+    if (0 == plen) {
+        return;
+    }
+    void *buf = malloc(plen);
+    CHECK(NULL != buf);
+    const void *packed = NULL;
+    int rc = ompi_datatype_get_pack_description(type, &packed);
+    CHECK(OMPI_SUCCESS == rc);
+    if (OMPI_SUCCESS != rc || NULL == buf) {
+        free(buf);
+        return;
+    }
+    memcpy(buf, packed, plen);
+
+    /* create_from_packed_description advances the cursor, so keep buf to
+     * free.  ompi_proc_local() works because main() points
+     * ompi_proc_local_proc at a dummy proc (same trick as ddt_pack.c);
+     * remote==local makes the heterogeneous byte-swap path a no-op.
+     *
+     * COVERAGE NOTE: this therefore does NOT exercise the big-endian
+     * byte-swap branch of __ompi_datatype_create_from_packed_description
+     * (the opal_swap_bytes8 loops over the size_t count and ptrdiff_t disp
+     * arrays).  Driving that path would require pre-swapping the packed
+     * buffer to mimic a different-endian sender, i.e. re-implementing the
+     * wire format here; it is better covered by a real heterogeneous run. */
+    void *cursor = buf;
+    ompi_datatype_t *rebuilt =
+        ompi_datatype_create_from_packed_description(&cursor, ompi_proc_local());
+    free(buf);
+    CHECK(NULL != rebuilt);
+    if (NULL == rebuilt) {
+        return;
+    }
+
+    /* Size, extent, and true extent must survive unchanged. */
+    size_t s0 = 0, s1 = 0;
+    ompi_datatype_type_size(type, &s0);
+    ompi_datatype_type_size(rebuilt, &s1);
+    CHECK(s0 == s1);
+
+    ptrdiff_t lb0, ext0, lb1, ext1, tlb0, text0, tlb1, text1;
+    ompi_datatype_get_extent(type, &lb0, &ext0);
+    ompi_datatype_get_extent(rebuilt, &lb1, &ext1);
+    CHECK(lb0 == lb1);
+    CHECK(ext0 == ext1);
+    ompi_datatype_get_true_extent(type, &tlb0, &text0);
+    ompi_datatype_get_true_extent(rebuilt, &tlb1, &text1);
+    CHECK(tlb0 == tlb1);
+    CHECK(text0 == text1);
+
+    /* Envelope must match: same combiner and the same number of each kind
+     * of argument.  In particular cl (large counts) must be preserved --
+     * if a bigcount were truncated into the int array on the way through,
+     * cl would shrink here. */
+    size_t ci0, cl0, ca0, cd0, ci1, cl1, ca1, cd1;
+    int32_t comb0 = -1, comb1 = -2;
+    CHECK(OMPI_SUCCESS
+          == ompi_datatype_get_args(type, 0, &ci0, NULL, &cl0, NULL, &ca0, NULL,
+                                    &cd0, NULL, &comb0));
+    CHECK(OMPI_SUCCESS
+          == ompi_datatype_get_args(rebuilt, 0, &ci1, NULL, &cl1, NULL, &ca1,
+                                    NULL, &cd1, NULL, &comb1));
+    CHECK(comb0 == comb1);
+    CHECK(ci0 == ci1);
+    CHECK(cl0 == cl1);
+    CHECK(ca0 == ca1);
+    CHECK(cd0 == cd1);
+
+    /* Every stored argument value -- ints, large counts, displacements, and
+     * constituent datatypes -- must survive the round-trip, not just the
+     * counts.  Compare the rebuilt type's args against the original's (the
+     * original's values are checked against the constructor inputs by the
+     * MPI-level constructor tests). */
+    if (ci0 == ci1 && cl0 == cl1 && ca0 == ca1 && cd0 == cd1) {
+        int *i0 = malloc((ci0 + 1) * sizeof(int));
+        int *i1 = malloc((ci1 + 1) * sizeof(int));
+        MPI_Count *l0 = malloc((cl0 + 1) * sizeof(MPI_Count));
+        MPI_Count *l1 = malloc((cl1 + 1) * sizeof(MPI_Count));
+        ptrdiff_t *a0 = malloc((ca0 + 1) * sizeof(ptrdiff_t));
+        ptrdiff_t *a1 = malloc((ca1 + 1) * sizeof(ptrdiff_t));
+        ompi_datatype_t **d0 = malloc((cd0 + 1) * sizeof(ompi_datatype_t *));
+        ompi_datatype_t **d1 = malloc((cd1 + 1) * sizeof(ompi_datatype_t *));
+
+        if (NULL == i0 || NULL == i1 || NULL == l0 || NULL == l1
+            || NULL == a0 || NULL == a1 || NULL == d0 || NULL == d1) {
+            CHECK(false); /* allocation failure */
+        } else {
+            size_t qi = ci0, ql = cl0, qa = ca0, qd = cd0;
+            CHECK(OMPI_SUCCESS
+                  == ompi_datatype_get_args(type, 1, &qi, i0, &ql, l0, &qa, a0,
+                                            &qd, d0, NULL));
+            qi = ci1; ql = cl1; qa = ca1; qd = cd1;
+            CHECK(OMPI_SUCCESS
+                  == ompi_datatype_get_args(rebuilt, 1, &qi, i1, &ql, l1, &qa,
+                                            a1, &qd, d1, NULL));
+
+            for (size_t k = 0; k < ci0; ++k) {
+                CHECK(i0[k] == i1[k]);
+            }
+            for (size_t k = 0; k < cl0; ++k) {
+                CHECK(l0[k] == l1[k]);
+            }
+            for (size_t k = 0; k < ca0; ++k) {
+                CHECK(a0[k] == a1[k]);
+            }
+            /* Constituent datatypes must be *equivalent*, but not necessarily
+             * the same handle: reconstruction canonicalizes predefined types
+             * by id (e.g. a packed MPI_INT rebuilds as ompi_mpi_int32_t), so
+             * check predefined-ness and size rather than pointer identity. */
+            for (size_t k = 0; k < cd0; ++k) {
+                size_t z0 = 0, z1 = 0;
+                ompi_datatype_type_size(d0[k], &z0);
+                ompi_datatype_type_size(d1[k], &z1);
+                CHECK(z0 == z1);
+                CHECK(ompi_datatype_is_predefined(d0[k])
+                      == ompi_datatype_is_predefined(d1[k]));
+            }
+        }
+
+        free(i0); free(i1); free(l0); free(l1);
+        free(a0); free(a1); free(d0); free(d1);
+    }
+
+    printf("  %-11s size=%" PRIuPTR " extent=%td combiner=%d cl=%zu  ok\n",
+           label, (uintptr_t) s0, ext0, (int) comb0, cl0);
+
+    if (!ompi_datatype_is_predefined(rebuilt)) {
+        ompi_datatype_destroy(&rebuilt);
+    }
+}
+
+static void test_pack_unpack_bigcount(void)
+{
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped)\n");
+        return;
+    }
+
+    ompi_datatype_t *old = &ompi_mpi_byte.dt;
+
+    /* contiguous: a single above-INT_MAX count (cl=1). */
+    {
+        MPI_Count count = (MPI_Count) INT_MAX + 7;
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS == ompi_datatype_create_contiguous(count, old, &t));
+        ompi_count_array_t a_i[1] = {OMPI_COUNT_ARRAY_CREATE(&count)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 1, a_i, 0, OMPI_DISP_ARRAY_NULL,
+                                        1, &old, MPI_COMBINER_CONTIGUOUS));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("contiguous", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* vector: above-INT_MAX count, blocklength, and (element) stride. */
+    {
+        MPI_Count count = (MPI_Count) INT_MAX + 5;
+        MPI_Count blen = (MPI_Count) INT_MAX + 6;
+        MPI_Count stride = (MPI_Count) INT_MAX + 7;
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_vector(count, blen, stride, old, &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(&blen),
+                                     OMPI_COUNT_ARRAY_CREATE(&stride)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 3, a_i, 0, OMPI_DISP_ARRAY_NULL,
+                                        1, &old, MPI_COMBINER_VECTOR));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("vector", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* indexed: 2 blocks, with an above-INT_MAX blocklength and (element)
+     * displacement. */
+    {
+        MPI_Count count = 2;
+        MPI_Count bl[2] = {(MPI_Count) INT_MAX + 5, 3};
+        MPI_Count disp[2] = {0, (MPI_Count) INT_MAX + 6};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_indexed(count, OMPI_COUNT_ARRAY_CREATE(bl),
+                                              OMPI_DISP_ARRAY_CREATE(disp), old,
+                                              &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(bl),
+                                     OMPI_COUNT_ARRAY_CREATE(disp)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 2 * count + 1, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, 1, &old,
+                                        MPI_COMBINER_INDEXED));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("indexed", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* hindexed: 2 blocks, above-INT_MAX blocklength and (byte)
+     * displacement. */
+    {
+        MPI_Count count = 2;
+        MPI_Count bl[2] = {(MPI_Count) INT_MAX + 5, 3};
+        MPI_Count disp[2] = {0, (MPI_Count) INT_MAX + 6};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_hindexed(count,
+                                               OMPI_COUNT_ARRAY_CREATE(bl),
+                                               OMPI_DISP_ARRAY_CREATE(disp), old,
+                                               &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(bl),
+                                     OMPI_COUNT_ARRAY_CREATE(disp)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 2 * count + 1, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, 1, &old,
+                                        MPI_COMBINER_HINDEXED));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("hindexed", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* struct: 2 heterogeneous blocks, above-INT_MAX blocklength and (byte)
+     * displacement. */
+    {
+        MPI_Count count = 2;
+        MPI_Count bl[2] = {(MPI_Count) INT_MAX + 5, 3};
+        MPI_Count disp[2] = {0, (MPI_Count) INT_MAX + 6};
+        ompi_datatype_t *types[2] = {&ompi_mpi_byte.dt, &ompi_mpi_int.dt};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_struct(count, OMPI_COUNT_ARRAY_CREATE(bl),
+                                             OMPI_DISP_ARRAY_CREATE(disp), types,
+                                             &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(bl),
+                                     OMPI_COUNT_ARRAY_CREATE(disp)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 2 * count + 1, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, count, types,
+                                        MPI_COMBINER_STRUCT));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("struct", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* struct with a *derived* (non-predefined) constituent: exercises the
+     * recursive pack/reconstruct path (OBJ_RETAIN + nested pack) that a
+     * predefined-only struct does not. */
+    {
+        ompi_datatype_t *inner = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_contiguous(2, &ompi_mpi_int.dt, &inner));
+        /* A derived type used as a struct member must carry its own args (the
+         * binding layer normally does this); set them so the recursive pack
+         * of the constituent has a description to walk. */
+        {
+            int two = 2;
+            ompi_count_array_t inner_a[1] = {OMPI_COUNT_ARRAY_CREATE(&two)};
+            ompi_datatype_t *inner_old = &ompi_mpi_int.dt;
+            CHECK(OMPI_SUCCESS
+                  == ompi_datatype_set_args(inner, 1, 0, inner_a, 0,
+                                            OMPI_DISP_ARRAY_NULL, 1, &inner_old,
+                                            MPI_COMBINER_CONTIGUOUS));
+        }
+        ompi_datatype_commit(&inner);
+
+        MPI_Count count = 2;
+        MPI_Count bl[2] = {(MPI_Count) INT_MAX + 5, 1};
+        MPI_Count disp[2] = {0, (MPI_Count) INT_MAX + 6};
+        ompi_datatype_t *types[2] = {&ompi_mpi_byte.dt, inner};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_struct(count, OMPI_COUNT_ARRAY_CREATE(bl),
+                                             OMPI_DISP_ARRAY_CREATE(disp), types,
+                                             &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(bl),
+                                     OMPI_COUNT_ARRAY_CREATE(disp)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 2 * count + 1, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, count, types,
+                                        MPI_COMBINER_STRUCT));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("struct+derived", t);
+        ompi_datatype_destroy(&t);
+        ompi_datatype_destroy(&inner);
+    }
+
+    /* hvector: above-INT_MAX count, blocklength, and (byte) stride. */
+    {
+        MPI_Count count = (MPI_Count) INT_MAX + 5;
+        MPI_Count blen = (MPI_Count) INT_MAX + 6;
+        MPI_Count stride = (MPI_Count) INT_MAX + 7; /* bytes */
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_hvector(count, blen, (ptrdiff_t) stride,
+                                              old, &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(&blen),
+                                     OMPI_COUNT_ARRAY_CREATE(&stride)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 3, a_i, 0, OMPI_DISP_ARRAY_NULL,
+                                        1, &old, MPI_COMBINER_HVECTOR));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("hvector", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* indexed_block: above-INT_MAX blocklength and (element) displacement. */
+    {
+        MPI_Count count = 2;
+        MPI_Count blen = (MPI_Count) INT_MAX + 5;
+        MPI_Count disp[2] = {0, (MPI_Count) INT_MAX + 6};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_indexed_block(count, blen,
+                                                    OMPI_DISP_ARRAY_CREATE(disp),
+                                                    old, &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(&blen),
+                                     OMPI_COUNT_ARRAY_CREATE(disp)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 2 + count, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, 1, &old,
+                                        MPI_COMBINER_INDEXED_BLOCK));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("indexed_block", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* hindexed_block: above-INT_MAX blocklength and (byte) displacement. */
+    {
+        MPI_Count count = 2;
+        MPI_Count blen = (MPI_Count) INT_MAX + 5;
+        MPI_Count disp[2] = {0, (MPI_Count) INT_MAX + 6};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_hindexed_block(count, blen,
+                                                     OMPI_DISP_ARRAY_CREATE(disp),
+                                                     old, &t));
+        ompi_count_array_t a_i[3] = {OMPI_COUNT_ARRAY_CREATE(&count),
+                                     OMPI_COUNT_ARRAY_CREATE(&blen),
+                                     OMPI_COUNT_ARRAY_CREATE(disp)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 2 + count, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, 1, &old,
+                                        MPI_COMBINER_HINDEXED_BLOCK));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("hindexed_block", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* subarray: above-INT_MAX size, subsize, and start in dimension 0. */
+    {
+        int ndims = 2, order = MPI_ORDER_C;
+        MPI_Count sizes[2] = {2 * (MPI_Count) INT_MAX + 100, 6};
+        MPI_Count subsizes[2] = {(MPI_Count) INT_MAX + 5, 2};
+        MPI_Count starts[2] = {(MPI_Count) INT_MAX + 3, 1};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_subarray(ndims,
+                                               OMPI_COUNT_ARRAY_CREATE(sizes),
+                                               OMPI_COUNT_ARRAY_CREATE(subsizes),
+                                               OMPI_COUNT_ARRAY_CREATE(starts),
+                                               order, old, &t));
+        ompi_count_array_t a_i[5] = {OMPI_COUNT_ARRAY_CREATE(&ndims),
+                                     OMPI_COUNT_ARRAY_CREATE(sizes),
+                                     OMPI_COUNT_ARRAY_CREATE(subsizes),
+                                     OMPI_COUNT_ARRAY_CREATE(starts),
+                                     OMPI_COUNT_ARRAY_CREATE(&order)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 2, 3 * ndims, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, 1, &old,
+                                        MPI_COMBINER_SUBARRAY));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("subarray", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* darray: 2-D, single process, above-INT_MAX gsizes. */
+    {
+        int size = 1, rank = 0, ndims = 2, order = MPI_ORDER_C;
+        MPI_Count gsizes[2] = {(MPI_Count) INT_MAX + 5,
+                               (MPI_Count) INT_MAX + 6};
+        int distribs[2] = {MPI_DISTRIBUTE_BLOCK, MPI_DISTRIBUTE_BLOCK};
+        int dargs[2] = {MPI_DISTRIBUTE_DFLT_DARG, MPI_DISTRIBUTE_DFLT_DARG};
+        int psizes[2] = {1, 1};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_darray(size, rank, ndims,
+                                             OMPI_COUNT_ARRAY_CREATE(gsizes),
+                                             distribs, dargs, psizes, order, old,
+                                             &t));
+        ompi_count_array_t a_i[8] = {OMPI_COUNT_ARRAY_CREATE(&size),
+                                     OMPI_COUNT_ARRAY_CREATE(&rank),
+                                     OMPI_COUNT_ARRAY_CREATE(&ndims),
+                                     OMPI_COUNT_ARRAY_CREATE(gsizes),
+                                     OMPI_COUNT_ARRAY_CREATE(distribs),
+                                     OMPI_COUNT_ARRAY_CREATE(dargs),
+                                     OMPI_COUNT_ARRAY_CREATE(psizes),
+                                     OMPI_COUNT_ARRAY_CREATE(&order)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 3 * ndims + 4, ndims, a_i, 0,
+                                        OMPI_DISP_ARRAY_NULL, 1, &old,
+                                        MPI_COMBINER_DARRAY));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("darray", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* resized: above-INT_MAX extent and a *negative* lb, exercising the
+     * large-count reconstruction branch of create_from_args and the
+     * signed round-trip of lb through the (unsigned) size_t count array. */
+    {
+        MPI_Count lb = -((MPI_Count) INT_MAX + 5);
+        MPI_Count extent = (MPI_Count) INT_MAX + 6;
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_resized(old, (ptrdiff_t) lb,
+                                              (ptrdiff_t) extent, &t));
+        MPI_Count a_l[2] = {lb, extent};
+        ompi_count_array_t a_i[1] = {OMPI_COUNT_ARRAY_CREATE(a_l)};
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 2, a_i, 0, OMPI_DISP_ARRAY_NULL,
+                                        1, &old, MPI_COMBINER_RESIZED));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("resized", t);
+        ompi_datatype_destroy(&t);
+    }
+
+    /* resized (classic form): lb/extent stored as MPI_Aint displacements
+     * (ca=2, cl=0), exercising the NULL == l reconstruction branch of
+     * create_from_args that the large-count resized case above does not. */
+    {
+        ptrdiff_t disp[2] = {-3, 4096};
+        ompi_datatype_t *t = NULL;
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_create_resized(old, disp[0], disp[1], &t));
+        CHECK(OMPI_SUCCESS
+              == ompi_datatype_set_args(t, 0, 0, NULL, 2,
+                                        OMPI_DISP_ARRAY_CREATE(disp), 1, &old,
+                                        MPI_COMBINER_RESIZED));
+        ompi_datatype_commit(&t);
+        pack_unpack_check("resized_aint", t);
+        ompi_datatype_destroy(&t);
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    /* Make ompi_proc_local() usable without MPI_Init (same approach as
+     * ddt_pack.c): the dummy proc is only compared against itself in the
+     * pack/unpack path, so its (uninitialized) fields never matter. */
+    /* Zero-init so that, even if a future pack/unpack change reads a remote
+     * proc field other than proc_arch, the test reads defined memory rather
+     * than uninitialized stack. */
+    struct ompi_proc_t dummy_proc;
+    memset(&dummy_proc, 0, sizeof(dummy_proc));
+    ompi_proc_local_proc = &dummy_proc;
+
+    opal_init(&argc, &argv);
+    ompi_datatype_init();
+
+    printf("--- ompi_datatype_create_contiguous (count > INT_MAX) ---\n");
+    test_create_contiguous_bigcount();
+    printf("--- ompi_datatype_set_args/get_args punning + oversized array ---\n");
+    test_set_get_args_bigcount();
+    printf("--- ompi_datatype_match_size (basic scalar only) ---\n");
+    test_match_size_basic_only();
+    printf("--- pack/unpack datatype description (count > INT_MAX) ---\n");
+    test_pack_unpack_bigcount();
+
+    opal_finalize();
+
+    if (0 == failures) {
+        printf("SUCCESS: all OMPI big-count datatype checks passed\n");
+        return 0;
+    }
+    fprintf(stderr, "FAILURE: %d OMPI big-count datatype check(s) failed\n",
+            failures);
+    return 1;
+}
diff --git a/test/datatype/partial.c b/ompi/test/datatype/partial.c
similarity index 99%
rename from test/datatype/partial.c
rename to ompi/test/datatype/partial.c
index 9721bf5388a..1efa1e2438b 100644
--- a/test/datatype/partial.c
+++ b/ompi/test/datatype/partial.c
@@ -175,7 +175,7 @@ int main(int argc, char *argv[])
     free(packed);
 
     /* clean-ups all data allocations */
-    opal_finalize_util();
+    opal_finalize();
 
     return 0;
 }
diff --git a/test/datatype/position.c b/ompi/test/datatype/position.c
similarity index 99%
rename from test/datatype/position.c
rename to ompi/test/datatype/position.c
index bd4f2834833..777a2b32c04 100644
--- a/test/datatype/position.c
+++ b/ompi/test/datatype/position.c
@@ -267,7 +267,7 @@ int main(int argc, char *argv[])
     }
     free(segments);
 
-    opal_finalize_util();
+    opal_finalize();
 
     return (0 == errors ? 0 : -1);
 }
diff --git a/test/datatype/position_noncontig.c b/ompi/test/datatype/position_noncontig.c
similarity index 99%
rename from test/datatype/position_noncontig.c
rename to ompi/test/datatype/position_noncontig.c
index 5d52dbb0243..61aa6d94b35 100644
--- a/test/datatype/position_noncontig.c
+++ b/ompi/test/datatype/position_noncontig.c
@@ -235,7 +235,7 @@ int main(int argc, char *argv[])
     }
     free(segments);
 
-    opal_finalize_util();
+    opal_finalize();
 
     return (0 == errors ? 0 : -1);
 }
diff --git a/test/datatype/reduce_local.c b/ompi/test/datatype/reduce_local.c
similarity index 99%
rename from test/datatype/reduce_local.c
rename to ompi/test/datatype/reduce_local.c
index a7e4a68a344..960826b59fc 100644
--- a/test/datatype/reduce_local.c
+++ b/ompi/test/datatype/reduce_local.c
@@ -1,3 +1,4 @@
+
 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
  * Copyright (c) 2019-2020 The University of Tennessee and The University
@@ -16,6 +17,10 @@
 /* needed for strsep() */
 #define _DEFAULT_SOURCE
 #define _BSD_SOURCE
+/* if we set all these flags, we need to also let sys/time.h define
+   gettimeofday() */
+#define __BSD_VISIBLE 1
+#define _XOPEN_SOURCE 700
 
 /* needed for posix_memalign() and getopt() */
 #define _POSIX_C_SOURCE 200809L
diff --git a/test/datatype/to_self.c b/ompi/test/datatype/to_self.c
similarity index 90%
rename from test/datatype/to_self.c
rename to ompi/test/datatype/to_self.c
index e7158bb7561..3f23c0faf64 100644
--- a/test/datatype/to_self.c
+++ b/ompi/test/datatype/to_self.c
@@ -218,19 +218,19 @@ static int cycles = 100;
 static int trials = 20;
 static int warmups = 2;
 
-static void print_result(int length, int trials, double *timers)
+static void print_result(int length, int num_trials, double *timers)
 {
     double bandwidth, clock_prec, temp;
     double min_time, max_time, average, std_dev = 0.0;
-    double ordered[trials];
+    double ordered[num_trials];
     int t, pos, quartile_start, quartile_end;
 
-    for (t = 0; t < trials; ordered[t] = timers[t], t++)
+    for (t = 0; t < num_trials; ordered[t] = timers[t], t++)
         ;
-    for (t = 0; t < trials - 1; t++) {
+    for (t = 0; t < num_trials - 1; t++) {
         temp = ordered[t];
         pos = t;
-        for (int i = t + 1; i < trials; i++) {
+        for (int i = t + 1; i < num_trials; i++) {
             if (temp > ordered[i]) {
                 temp = ordered[i];
                 pos = i;
@@ -242,8 +242,8 @@ static void print_result(int length, int trials, double *timers)
             ordered[pos] = temp;
         }
     }
-    quartile_start = trials - (3 * trials) / 4;
-    quartile_end = trials - (1 * trials) / 4;
+    quartile_start = num_trials - (3 * num_trials) / 4;
+    quartile_end = num_trials - (1 * num_trials) / 4;
     clock_prec = MPI_Wtick();
     min_time = ordered[quartile_start];
     max_time = ordered[quartile_start];
@@ -266,7 +266,7 @@ static void print_result(int length, int trials, double *timers)
            min_time, max_time, (100.0 * std_dev) / average);
 }
 
-static int pack(int cycles, MPI_Datatype sdt, int scount, void *sbuf, void *packed_buf)
+static int pack(int num_cycles, MPI_Datatype sdt, int scount, void *sbuf, void *packed_buf)
 {
     int position, myself, c, t, outsize;
     double timers[trials];
@@ -277,7 +277,7 @@ static int pack(int cycles, MPI_Datatype sdt, int scount, void *sbuf, void *pack
     MPI_Comm_rank(MPI_COMM_WORLD, &myself);
 
     for (t = 0; t < warmups; t++) {
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             position = 0;
             MPI_Pack(sbuf, scount, sdt, packed_buf, outsize, &position, MPI_COMM_WORLD);
         }
@@ -285,17 +285,17 @@ static int pack(int cycles, MPI_Datatype sdt, int scount, void *sbuf, void *pack
 
     for (t = 0; t < trials; t++) {
         timers[t] = MPI_Wtime();
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             position = 0;
             MPI_Pack(sbuf, scount, sdt, packed_buf, outsize, &position, MPI_COMM_WORLD);
         }
-        timers[t] = (MPI_Wtime() - timers[t]) / cycles;
+        timers[t] = (MPI_Wtime() - timers[t]) / num_cycles;
     }
     print_result(outsize, trials, timers);
     return 0;
 }
 
-static int unpack(int cycles, void *packed_buf, MPI_Datatype rdt, int rcount, void *rbuf)
+static int unpack(int num_cycles, void *packed_buf, MPI_Datatype rdt, int rcount, void *rbuf)
 {
     int position, myself, c, t, insize;
     double timers[trials];
@@ -306,7 +306,7 @@ static int unpack(int cycles, void *packed_buf, MPI_Datatype rdt, int rcount, vo
     MPI_Comm_rank(MPI_COMM_WORLD, &myself);
 
     for (t = 0; t < warmups; t++) {
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             position = 0;
             MPI_Unpack(packed_buf, insize, &position, rbuf, rcount, rdt, MPI_COMM_WORLD);
         }
@@ -314,17 +314,17 @@ static int unpack(int cycles, void *packed_buf, MPI_Datatype rdt, int rcount, vo
 
     for (t = 0; t < trials; t++) {
         timers[t] = MPI_Wtime();
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             position = 0;
             MPI_Unpack(packed_buf, insize, &position, rbuf, rcount, rdt, MPI_COMM_WORLD);
         }
-        timers[t] = (MPI_Wtime() - timers[t]) / cycles;
+        timers[t] = (MPI_Wtime() - timers[t]) / num_cycles;
     }
     print_result(insize, trials, timers);
     return 0;
 }
 
-static int isend_recv(int cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
+static int isend_recv(int num_cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
                       int rcount, void *rbuf)
 {
     int myself, tag = 0, c, t, slength, rlength;
@@ -341,18 +341,18 @@ static int isend_recv(int cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_
 
     for (t = 0; t < trials; t++) {
         timers[t] = MPI_Wtime();
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             MPI_Isend(sbuf, scount, sdt, myself, tag, MPI_COMM_WORLD, &req);
             MPI_Recv(rbuf, rcount, rdt, myself, tag, MPI_COMM_WORLD, &status);
             MPI_Wait(&req, &status);
         }
-        timers[t] = (MPI_Wtime() - timers[t]) / cycles;
+        timers[t] = (MPI_Wtime() - timers[t]) / num_cycles;
     }
     print_result(rlength, trials, timers);
     return 0;
 }
 
-static int irecv_send(int cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
+static int irecv_send(int num_cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
                       int rcount, void *rbuf)
 {
     int myself, tag = 0, c, t, slength, rlength;
@@ -369,18 +369,18 @@ static int irecv_send(int cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_
 
     for (t = 0; t < trials; t++) {
         timers[t] = MPI_Wtime();
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             MPI_Irecv(rbuf, rcount, rdt, myself, tag, MPI_COMM_WORLD, &req);
             MPI_Send(sbuf, scount, sdt, myself, tag, MPI_COMM_WORLD);
             MPI_Wait(&req, &status);
         }
-        timers[t] = (MPI_Wtime() - timers[t]) / cycles;
+        timers[t] = (MPI_Wtime() - timers[t]) / num_cycles;
     }
     print_result(rlength, trials, timers);
     return 0;
 }
 
-static int isend_irecv_wait(int cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
+static int isend_irecv_wait(int num_cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
                             int rcount, void *rbuf)
 {
     int myself, tag = 0, c, t, slength, rlength;
@@ -397,18 +397,18 @@ static int isend_irecv_wait(int cycles, MPI_Datatype sdt, int scount, void *sbuf
 
     for (t = 0; t < trials; t++) {
         timers[t] = MPI_Wtime();
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             MPI_Isend(sbuf, scount, sdt, myself, tag, MPI_COMM_WORLD, &requests[0]);
             MPI_Irecv(rbuf, rcount, rdt, myself, tag, MPI_COMM_WORLD, &requests[1]);
             MPI_Waitall(2, requests, statuses);
         }
-        timers[t] = (MPI_Wtime() - timers[t]) / cycles;
+        timers[t] = (MPI_Wtime() - timers[t]) / num_cycles;
     }
     print_result(rlength, trials, timers);
     return 0;
 }
 
-static int irecv_isend_wait(int cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
+static int irecv_isend_wait(int num_cycles, MPI_Datatype sdt, int scount, void *sbuf, MPI_Datatype rdt,
                             int rcount, void *rbuf)
 {
     int myself, tag = 0, c, t, slength, rlength;
@@ -425,12 +425,12 @@ static int irecv_isend_wait(int cycles, MPI_Datatype sdt, int scount, void *sbuf
 
     for (t = 0; t < trials; t++) {
         timers[t] = MPI_Wtime();
-        for (c = 0; c < cycles; c++) {
+        for (c = 0; c < num_cycles; c++) {
             MPI_Irecv(rbuf, rcount, rdt, myself, tag, MPI_COMM_WORLD, &requests[0]);
             MPI_Isend(sbuf, scount, sdt, myself, tag, MPI_COMM_WORLD, &requests[1]);
             MPI_Waitall(2, requests, statuses);
         }
-        timers[t] = (MPI_Wtime() - timers[t]) / cycles;
+        timers[t] = (MPI_Wtime() - timers[t]) / num_cycles;
     }
     print_result(rlength, trials, timers);
     return 0;
diff --git a/test/datatype/unpack_ooo.c b/ompi/test/datatype/unpack_ooo.c
similarity index 97%
rename from test/datatype/unpack_ooo.c
rename to ompi/test/datatype/unpack_ooo.c
index 7fdfe790916..dd78d71240a 100644
--- a/test/datatype/unpack_ooo.c
+++ b/ompi/test/datatype/unpack_ooo.c
@@ -6,6 +6,7 @@
  * Copyright (c) 2014      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2015 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -264,7 +265,8 @@ static int unpack_ooo(void)
     len[0] = 1;
     len[1] = 1;
 
-    rc = ompi_datatype_create_struct(2, len, disp, type, &newtype);
+    rc = ompi_datatype_create_struct(2, OMPI_COUNT_ARRAY_CREATE(len),
+                                     OMPI_DISP_ARRAY_CREATE(disp), type, &newtype);
     if (OMPI_SUCCESS != rc) {
         fprintf(stderr, "could not create struct\n");
         return 1;
diff --git a/ompi/test/file/Makefile.am b/ompi/test/file/Makefile.am
new file mode 100644
index 00000000000..912c93c0be6
--- /dev/null
+++ b/ompi/test/file/Makefile.am
@@ -0,0 +1,52 @@
+# -*- makefile -*-
+#
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+# These are single-process OMPIO MPI_File info tests.  Each calls
+# MPI_Init and performs all of its I/O on MPI_COMM_SELF, so they need no
+# launcher and can run as part of 'make check'.  They exercise the OMPIO
+# MPI_Info hint reporting required by MPI-5.0 sec. 15.2.8 (Open MPI issue
+# #13367).
+
+# Make "make check" work in an uninstalled --enable-mca-dso build tree
+include $(top_srcdir)/Makefile.mca-dso-check
+
+check_PROGRAMS = \
+        file_info_defaults \
+        file_info_hints \
+        file_info_set_view \
+        file_info_memkind
+TESTS = $(check_PROGRAMS)
+
+common_headers = ompio_file_info_common.h
+common_ldflags = $(OMPI_PKG_CONFIG_LDFLAGS)
+common_ldadd = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+
+file_info_defaults_SOURCES = file_info_defaults.c $(common_headers)
+file_info_defaults_LDFLAGS = $(common_ldflags)
+file_info_defaults_LDADD = $(common_ldadd)
+
+file_info_hints_SOURCES = file_info_hints.c $(common_headers)
+file_info_hints_LDFLAGS = $(common_ldflags)
+file_info_hints_LDADD = $(common_ldadd)
+
+file_info_set_view_SOURCES = file_info_set_view.c $(common_headers)
+file_info_set_view_LDFLAGS = $(common_ldflags)
+file_info_set_view_LDADD = $(common_ldadd)
+
+file_info_memkind_SOURCES = file_info_memkind.c $(common_headers)
+file_info_memkind_LDFLAGS = $(common_ldflags)
+file_info_memkind_LDADD = $(common_ldadd)
+
+distclean-local:
+	rm -rf *.dSYM .deps .libs *.la *.lo *.log *.o *.trs \
+		file_info_defaults file_info_hints file_info_set_view \
+		file_info_memkind Makefile
diff --git a/ompi/test/file/file_info_defaults.c b/ompi/test/file/file_info_defaults.c
new file mode 100644
index 00000000000..d3a40b45a03
--- /dev/null
+++ b/ompi/test/file/file_info_defaults.c
@@ -0,0 +1,77 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * Single-process (no launcher required) regression test for Open MPI
+ * issue #13367: MPI_File_get_info on an OMPIO file opened with
+ * MPI_INFO_NULL must return the implementation's supported, defaulted
+ * file hints rather than an empty info object.
+ *
+ * MPI-5.0 section 15.2.8 requires the info object returned by
+ * MPI_File_get_info to contain the current setting of all hints
+ * associated with the file, including hints the implementation supports
+ * with default values.
+ */
+
+#include "ompio_file_info_common.h"
+
+int main(int argc, char *argv[])
+{
+    const char *name = "file_info_defaults";
+    finfo_result_t res = {0, 0};
+    char filename[256];
+    MPI_File fh;
+    MPI_Info info_used;
+    int rc;
+
+    MPI_Init(&argc, &argv);
+
+    /* Make MPI_File_open report failures instead of aborting. */
+    MPI_File_set_errhandler(MPI_FILE_NULL, MPI_ERRORS_RETURN);
+
+    finfo_make_filename(filename, sizeof(filename), "defaults");
+
+    rc = finfo_open(&fh, filename, MPI_INFO_NULL);
+    finfo_check_rc(&res, rc, "MPI_File_open(MPI_INFO_NULL)");
+    if (MPI_SUCCESS != rc) {
+        MPI_Finalize();
+        return finfo_finish(name, &res);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    finfo_check_rc(&res, rc, "MPI_File_get_info");
+    if (MPI_SUCCESS == rc) {
+        /*
+         * The headline #13367 symptom: a file opened with MPI_INFO_NULL
+         * reported zero hints.  Require a non-empty, well-formed result.
+         */
+        finfo_expect_nonempty(&res, info_used);
+
+        /*
+         * OMPIO core registers these hints with defaults, so they must
+         * appear even though the user supplied no info.
+         */
+        finfo_expect_key(&res, info_used, "cb_buffer_size");
+        finfo_expect_value(&res, info_used, "collective_buffering", "true");
+
+        /*
+         * cb_nodes defaults to the internal "-1" (auto) sentinel, which
+         * must never be reported to the application: the hint is either
+         * omitted or carries a real aggregator count.
+         */
+        finfo_expect_absent_or_not_value(&res, info_used, "cb_nodes", "-1");
+
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_close(&fh);
+    finfo_check_rc(&res, rc, "MPI_File_close");
+
+    MPI_Finalize();
+    return finfo_finish(name, &res);
+}
diff --git a/ompi/test/file/file_info_hints.c b/ompi/test/file/file_info_hints.c
new file mode 100644
index 00000000000..26284461c3d
--- /dev/null
+++ b/ompi/test/file/file_info_hints.c
@@ -0,0 +1,110 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * Single-process (no launcher required) test for OMPIO MPI_Info hint
+ * handling at MPI_File_open and MPI_File_set_info time.
+ *
+ * MPI-5.0 section 15.2.8 requires that an accepted user hint be reflected
+ * by MPI_File_get_info, that an unknown/ignored hint not be reported, and
+ * that MPI_File_set_info update the named hints while leaving previous and
+ * default values for omitted (or ignored) hints in effect.
+ */
+
+#include "ompio_file_info_common.h"
+
+int main(int argc, char *argv[])
+{
+    const char *name = "file_info_hints";
+    finfo_result_t res = {0, 0};
+    char filename[256];
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    int rc;
+
+    MPI_Init(&argc, &argv);
+    MPI_File_set_errhandler(MPI_FILE_NULL, MPI_ERRORS_RETURN);
+
+    finfo_make_filename(filename, sizeof(filename), "hints");
+
+    /* Open with a supported hint plus an unknown one. */
+    rc = MPI_Info_create(&info);
+    finfo_check_rc(&res, rc, "MPI_Info_create");
+    if (MPI_SUCCESS != rc) {
+        MPI_Finalize();
+        return finfo_finish(name, &res);
+    }
+    MPI_Info_set(info, "cb_buffer_size", "12345");
+    MPI_Info_set(info, "unknown_ompio_hint", "ignore-me");
+
+    rc = finfo_open(&fh, filename, info);
+    finfo_check_rc(&res, rc, "MPI_File_open(user hints)");
+    MPI_Info_free(&info);
+    if (MPI_SUCCESS != rc) {
+        MPI_Finalize();
+        return finfo_finish(name, &res);
+    }
+
+    /* The accepted hint must be reported; the unknown one must not. */
+    rc = MPI_File_get_info(fh, &info_used);
+    finfo_check_rc(&res, rc, "MPI_File_get_info (after open)");
+    if (MPI_SUCCESS == rc) {
+        finfo_expect_value(&res, info_used, "cb_buffer_size", "12345");
+        finfo_expect_value(&res, info_used, "collective_buffering", "true");
+        finfo_expect_no_key(&res, info_used, "unknown_ompio_hint");
+        MPI_Info_free(&info_used);
+    }
+
+    /* MPI_File_set_info updates a mutable hint; unknown keys are ignored. */
+    rc = MPI_Info_create(&info);
+    finfo_check_rc(&res, rc, "MPI_Info_create");
+    if (MPI_SUCCESS == rc) {
+        MPI_Info_set(info, "cb_buffer_size", "23456");
+        MPI_Info_set(info, "unknown_ompio_hint", "still-ignore-me");
+        rc = MPI_File_set_info(fh, info);
+        finfo_check_rc(&res, rc, "MPI_File_set_info (update)");
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    finfo_check_rc(&res, rc, "MPI_File_get_info (after set_info)");
+    if (MPI_SUCCESS == rc) {
+        finfo_expect_value(&res, info_used, "cb_buffer_size", "23456");
+        /* A hint not named in set_info keeps its previous/default value. */
+        finfo_expect_value(&res, info_used, "collective_buffering", "true");
+        finfo_expect_no_key(&res, info_used, "unknown_ompio_hint");
+        finfo_expect_absent_or_not_value(&res, info_used, "cb_nodes", "-1");
+        MPI_Info_free(&info_used);
+    }
+
+    /* set_info with only an unknown key must leave prior hints untouched. */
+    rc = MPI_Info_create(&info);
+    finfo_check_rc(&res, rc, "MPI_Info_create");
+    if (MPI_SUCCESS == rc) {
+        MPI_Info_set(info, "unknown_ompio_hint", "unknown-only");
+        rc = MPI_File_set_info(fh, info);
+        finfo_check_rc(&res, rc, "MPI_File_set_info (unknown only)");
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    finfo_check_rc(&res, rc, "MPI_File_get_info (after unknown-only set_info)");
+    if (MPI_SUCCESS == rc) {
+        finfo_expect_value(&res, info_used, "cb_buffer_size", "23456");
+        finfo_expect_value(&res, info_used, "collective_buffering", "true");
+        finfo_expect_no_key(&res, info_used, "unknown_ompio_hint");
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_close(&fh);
+    finfo_check_rc(&res, rc, "MPI_File_close");
+
+    MPI_Finalize();
+    return finfo_finish(name, &res);
+}
diff --git a/ompi/test/file/file_info_memkind.c b/ompi/test/file/file_info_memkind.c
new file mode 100644
index 00000000000..025c7d3b00a
--- /dev/null
+++ b/ompi/test/file/file_info_memkind.c
@@ -0,0 +1,177 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * Single-process (no launcher required) test for the MPI-4.1
+ * memory-allocation-kind info keys on MPI_File objects.
+ *
+ * MPI-5.0 section 11.4.3 requires that "mpi_memory_alloc_kinds" be
+ * contained in the info object returned by MPI_FILE_GET_INFO, and that
+ * for a file derived from the World Model its value be identical to the
+ * value reported by MPI_COMM_GET_INFO on MPI_COMM_WORLD/MPI_COMM_SELF.
+ * It further requires (sections 11.4.3 and 14.2.8) that when the user
+ * asserts a supported set of kinds via "mpi_assert_memory_alloc_kinds"
+ * at file-open time, MPI_FILE_GET_INFO return that key with a value
+ * identical to the one the user supplied.
+ *
+ * Open MPI only populates "mpi_memory_alloc_kinds" when the kinds were
+ * requested (via the OMPI_MCA_mpi_memory_alloc_kinds MCA parameter, read
+ * when the World Model instance is built; see
+ * ompi/communicator/comm_init.c).  This test therefore requests "system"
+ * -- a kind that is always supported -- in the environment before
+ * MPI_Init, then verifies that the file layer carries the keys through
+ * open, set_info, and set_view.
+ */
+
+#include "ompio_file_info_common.h"
+
+int main(int argc, char *argv[])
+{
+    const char *name = "file_info_memkind";
+    finfo_result_t res = {0, 0};
+    char filename[256];
+    char world_kinds[MPI_MAX_INFO_VAL + 1];
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    MPI_Info world_info;
+    int rc;
+
+    /*
+     * Request a supported memory allocation kind before MPI is
+     * initialized; Open MPI reads this when it constructs the World Model
+     * instance.  setenv() with overwrite forces a deterministic value
+     * regardless of the caller's environment.
+     */
+    setenv("OMPI_MCA_mpi_memory_alloc_kinds", "system", 1);
+
+    MPI_Init(&argc, &argv);
+    MPI_File_set_errhandler(MPI_FILE_NULL, MPI_ERRORS_RETURN);
+
+    /*
+     * Capture the World Model reference value.  MPI is free to report
+     * additional kinds beyond the requested "system", so the file checks
+     * below compare against whatever MPI_COMM_WORLD reports rather than a
+     * hard-coded spelling.
+     */
+    rc = MPI_Comm_get_info(MPI_COMM_WORLD, &world_info);
+    finfo_check_rc(&res, rc, "MPI_Comm_get_info(MPI_COMM_WORLD)");
+    if (MPI_SUCCESS != rc) {
+        /* A failed query is a real error, not a skip. */
+        MPI_Finalize();
+        return finfo_finish(name, &res);
+    }
+    if (!finfo_info_get(world_info, "mpi_memory_alloc_kinds", world_kinds)) {
+        /*
+         * The instance did not pick up the requested kinds (for example,
+         * the MCA parameter was pinned to a different value in the
+         * environment).  There is no reference value to compare against,
+         * so mark the whole test skipped.  Automake's exit-status test
+         * driver treats exit code 77 as SKIP; returning it keeps a
+         * lost-coverage environment visible under 'make check' instead of
+         * reporting a false PASS.
+         */
+        printf("SKIP: mpi_memory_alloc_kinds not reported on MPI_COMM_WORLD; "
+               "nothing to test\n");
+        MPI_Info_free(&world_info);
+        MPI_Finalize();
+        return 77;
+    }
+    printf("INFO: MPI_COMM_WORLD mpi_memory_alloc_kinds = '%s'\n", world_kinds);
+    MPI_Info_free(&world_info);
+
+    finfo_make_filename(filename, sizeof(filename), "memkind");
+
+    /*
+     * Case 1: a file opened with MPI_INFO_NULL must still report
+     * mpi_memory_alloc_kinds, and the value must match the World Model
+     * value.  It must also survive set_info (which cannot update or
+     * delete the key) and set_view (which rebuilds the reported hint set
+     * from a staged copy).
+     */
+    rc = finfo_open(&fh, filename, MPI_INFO_NULL);
+    finfo_check_rc(&res, rc, "MPI_File_open(MPI_INFO_NULL)");
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_File_get_info(fh, &info_used);
+        finfo_check_rc(&res, rc, "MPI_File_get_info (after open)");
+        if (MPI_SUCCESS == rc) {
+            finfo_expect_value(&res, info_used, "mpi_memory_alloc_kinds",
+                               world_kinds);
+            MPI_Info_free(&info_used);
+        }
+
+        rc = MPI_Info_create(&info);
+        finfo_check_rc(&res, rc, "MPI_Info_create (set_info)");
+        if (MPI_SUCCESS == rc) {
+            /* Update an unrelated hint; the memkind key must be untouched. */
+            MPI_Info_set(info, "cb_buffer_size", "65536");
+            rc = MPI_File_set_info(fh, info);
+            finfo_check_rc(&res, rc, "MPI_File_set_info");
+            MPI_Info_free(&info);
+        }
+        rc = MPI_File_get_info(fh, &info_used);
+        finfo_check_rc(&res, rc, "MPI_File_get_info (after set_info)");
+        if (MPI_SUCCESS == rc) {
+            finfo_expect_value(&res, info_used, "mpi_memory_alloc_kinds",
+                               world_kinds);
+            MPI_Info_free(&info_used);
+        }
+
+        rc = MPI_File_set_view(fh, 0, MPI_BYTE, MPI_BYTE, "native",
+                               MPI_INFO_NULL);
+        finfo_check_rc(&res, rc, "MPI_File_set_view");
+        rc = MPI_File_get_info(fh, &info_used);
+        finfo_check_rc(&res, rc, "MPI_File_get_info (after set_view)");
+        if (MPI_SUCCESS == rc) {
+            finfo_expect_value(&res, info_used, "mpi_memory_alloc_kinds",
+                               world_kinds);
+            MPI_Info_free(&info_used);
+        }
+
+        rc = MPI_File_close(&fh);
+        finfo_check_rc(&res, rc, "MPI_File_close");
+    }
+
+    /*
+     * Case 2: assert a supported subset of kinds at open time.  Because
+     * "system" is supported, the implementation recognizes the assertion
+     * and MPI_File_get_info must return mpi_assert_memory_alloc_kinds
+     * identical to the supplied value, alongside mpi_memory_alloc_kinds.
+     */
+    rc = MPI_Info_create(&info);
+    finfo_check_rc(&res, rc, "MPI_Info_create (assert)");
+    if (MPI_SUCCESS == rc) {
+        MPI_Info_set(info, "mpi_assert_memory_alloc_kinds", "system");
+        rc = finfo_open(&fh, filename, info);
+        finfo_check_rc(&res, rc, "MPI_File_open(mpi_assert_memory_alloc_kinds)");
+        MPI_Info_free(&info);
+        if (MPI_SUCCESS == rc) {
+            rc = MPI_File_get_info(fh, &info_used);
+            finfo_check_rc(&res, rc, "MPI_File_get_info (assert)");
+            if (MPI_SUCCESS == rc) {
+                finfo_expect_value(&res, info_used,
+                                   "mpi_assert_memory_alloc_kinds", "system");
+                /*
+                 * A recognized assertion narrows the reported kinds: the
+                 * file must report exactly the asserted "system", not the
+                 * broader World Model value (which also contains "mpi").
+                 * Checking only presence would let a regression that left
+                 * the parent value in place slip through.
+                 */
+                finfo_expect_value(&res, info_used, "mpi_memory_alloc_kinds",
+                                   "system");
+                MPI_Info_free(&info_used);
+            }
+            rc = MPI_File_close(&fh);
+            finfo_check_rc(&res, rc, "MPI_File_close (assert)");
+        }
+    }
+
+    MPI_Finalize();
+    return finfo_finish(name, &res);
+}
diff --git a/ompi/test/file/file_info_set_view.c b/ompi/test/file/file_info_set_view.c
new file mode 100644
index 00000000000..1178acddd53
--- /dev/null
+++ b/ompi/test/file/file_info_set_view.c
@@ -0,0 +1,107 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * Single-process (no launcher required) test for OMPIO MPI_Info hint
+ * handling at MPI_File_set_view time.
+ *
+ * The info argument to MPI_File_set_view is routed through the same hint
+ * subscription mechanism as open/set_info: view-related hints that OMPIO
+ * accepts (here cb_nodes and collective_buffering) must be reflected by a
+ * subsequent MPI_File_get_info, unknown keys must not be reported, and
+ * hints that were in effect before the view change must be preserved.
+ */
+
+#include "ompio_file_info_common.h"
+
+int main(int argc, char *argv[])
+{
+    const char *name = "file_info_set_view";
+    finfo_result_t res = {0, 0};
+    char filename[256];
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    MPI_Datatype filetype;
+    int rc;
+
+    MPI_Init(&argc, &argv);
+    MPI_File_set_errhandler(MPI_FILE_NULL, MPI_ERRORS_RETURN);
+
+    finfo_make_filename(filename, sizeof(filename), "set-view");
+
+    rc = finfo_open(&fh, filename, MPI_INFO_NULL);
+    finfo_check_rc(&res, rc, "MPI_File_open(MPI_INFO_NULL)");
+    if (MPI_SUCCESS != rc) {
+        MPI_Finalize();
+        return finfo_finish(name, &res);
+    }
+
+    /* A simple committed filetype is enough to set a view. */
+    rc = MPI_Type_contiguous(2, MPI_BYTE, &filetype);
+    finfo_check_rc(&res, rc, "MPI_Type_contiguous");
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_Type_commit(&filetype);
+        finfo_check_rc(&res, rc, "MPI_Type_commit");
+    }
+    if (MPI_SUCCESS != rc) {
+        MPI_File_close(&fh);
+        MPI_Finalize();
+        return finfo_finish(name, &res);
+    }
+
+    /* Set a view carrying view-related hints plus an unknown one. */
+    rc = MPI_Info_create(&info);
+    finfo_check_rc(&res, rc, "MPI_Info_create");
+    if (MPI_SUCCESS == rc) {
+        MPI_Info_set(info, "cb_nodes", "1");
+        MPI_Info_set(info, "collective_buffering", "false");
+        MPI_Info_set(info, "unknown_ompio_hint", "set-view-ignore-me");
+        rc = MPI_File_set_view(fh, 0, MPI_BYTE, filetype, "native", info);
+        finfo_check_rc(&res, rc, "MPI_File_set_view (with hints)");
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    finfo_check_rc(&res, rc, "MPI_File_get_info (after set_view)");
+    if (MPI_SUCCESS == rc) {
+        finfo_expect_value(&res, info_used, "cb_nodes", "1");
+        finfo_expect_value(&res, info_used, "collective_buffering", "false");
+        finfo_expect_no_key(&res, info_used, "unknown_ompio_hint");
+        /* Default hints from open survive a view change. */
+        finfo_expect_key(&res, info_used, "cb_buffer_size");
+        MPI_Info_free(&info_used);
+    }
+
+    /* A second view with only an unknown key preserves the prior hints. */
+    rc = MPI_Info_create(&info);
+    finfo_check_rc(&res, rc, "MPI_Info_create");
+    if (MPI_SUCCESS == rc) {
+        MPI_Info_set(info, "unknown_ompio_hint", "unknown-only-set-view");
+        rc = MPI_File_set_view(fh, 0, MPI_BYTE, filetype, "native", info);
+        finfo_check_rc(&res, rc, "MPI_File_set_view (unknown only)");
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    finfo_check_rc(&res, rc, "MPI_File_get_info (after unknown-only set_view)");
+    if (MPI_SUCCESS == rc) {
+        finfo_expect_value(&res, info_used, "cb_nodes", "1");
+        finfo_expect_value(&res, info_used, "collective_buffering", "false");
+        finfo_expect_no_key(&res, info_used, "unknown_ompio_hint");
+        MPI_Info_free(&info_used);
+    }
+
+    MPI_Type_free(&filetype);
+
+    rc = MPI_File_close(&fh);
+    finfo_check_rc(&res, rc, "MPI_File_close");
+
+    MPI_Finalize();
+    return finfo_finish(name, &res);
+}
diff --git a/ompi/test/file/ompio_file_info_common.h b/ompi/test/file/ompio_file_info_common.h
new file mode 100644
index 00000000000..ee450cea0b3
--- /dev/null
+++ b/ompi/test/file/ompio_file_info_common.h
@@ -0,0 +1,226 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * Shared helpers for the single-process OMPIO MPI_File info tests.
+ *
+ * These tests are singletons: each calls MPI_Init and performs all of
+ * its file I/O on MPI_COMM_SELF, so they need no launcher and can run as
+ * part of 'make check'.  They exercise the OMPIO MPI_Info hint reporting
+ * required by MPI-5.0 section 15.2.8 and added for Open MPI issue #13367
+ * ("MPI_File_get_info fails to return hints as required by MPI
+ * standard"): MPI_File_get_info must return every supported hint (its
+ * implementation default, any accepted user value, and any value set by
+ * the implementation), and must not return unknown or ignored user
+ * hints.
+ *
+ * The helpers below are 'static inline' so that an unused helper in any
+ * one test does not trigger -Wunused-function.
+ */
+
+#ifndef OMPIO_FILE_INFO_COMMON_H
+#define OMPIO_FILE_INFO_COMMON_H
+
+#include "mpi.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* Running tally of assertions for a single test program. */
+typedef struct {
+    int checks;     /* total assertions made */
+    int failures;   /* assertions that failed */
+} finfo_result_t;
+
+/*
+ * Look up a key in an info object.  Returns 1 and copies the value into
+ * 'value' (a buffer of at least MPI_MAX_INFO_VAL + 1 bytes) if present,
+ * otherwise returns 0.
+ */
+static inline int finfo_info_get(MPI_Info info, const char *key, char *value)
+{
+    int flag = 0;
+    int buflen = MPI_MAX_INFO_VAL;
+
+    value[0] = '\0';
+    MPI_Info_get_string(info, key, &buflen, value, &flag);
+    return flag;
+}
+
+/* Check that an MPI call returned MPI_SUCCESS. */
+static inline void finfo_check_rc(finfo_result_t *res, int rc, const char *call)
+{
+    char errstr[MPI_MAX_ERROR_STRING];
+    int len = 0;
+
+    ++res->checks;
+    if (MPI_SUCCESS != rc) {
+        ++res->failures;
+        MPI_Error_string(rc, errstr, &len);
+        printf("FAIL: %s returned MPI error %d (%.*s)\n", call, rc, len, errstr);
+    }
+}
+
+/* Assert that 'key' is present (with any value). */
+static inline void finfo_expect_key(finfo_result_t *res, MPI_Info info,
+                                  const char *key)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    ++res->checks;
+    if (!finfo_info_get(info, key, value)) {
+        ++res->failures;
+        printf("FAIL: expected hint '%s' to be present\n", key);
+    } else {
+        printf("PASS: hint '%s' present (= '%s')\n", key, value);
+    }
+}
+
+/* Assert that 'key' is present and equal to 'expected'. */
+static inline void finfo_expect_value(finfo_result_t *res, MPI_Info info,
+                                    const char *key, const char *expected)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    ++res->checks;
+    if (!finfo_info_get(info, key, value)) {
+        ++res->failures;
+        printf("FAIL: expected hint '%s' = '%s', but it was absent\n",
+               key, expected);
+    } else if (0 != strcmp(value, expected)) {
+        ++res->failures;
+        printf("FAIL: expected hint '%s' = '%s', got '%s'\n",
+               key, expected, value);
+    } else {
+        printf("PASS: hint '%s' = '%s'\n", key, value);
+    }
+}
+
+/* Assert that 'key' is not reported at all. */
+static inline void finfo_expect_no_key(finfo_result_t *res, MPI_Info info,
+                                     const char *key)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    ++res->checks;
+    if (finfo_info_get(info, key, value)) {
+        ++res->failures;
+        printf("FAIL: hint '%s' should not be reported, but got '%s'\n",
+               key, value);
+    } else {
+        printf("PASS: hint '%s' correctly not reported\n", key);
+    }
+}
+
+/*
+ * Assert that 'key' is either absent or, if present, not equal to the
+ * 'rejected' value.  Used for hints (such as cb_nodes) whose internal
+ * sentinel value must never be reported to the application.
+ */
+static inline void finfo_expect_absent_or_not_value(finfo_result_t *res,
+                                                  MPI_Info info,
+                                                  const char *key,
+                                                  const char *rejected)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    ++res->checks;
+    if (finfo_info_get(info, key, value) && 0 == strcmp(value, rejected)) {
+        ++res->failures;
+        printf("FAIL: hint '%s' must never be reported as '%s'\n",
+               key, rejected);
+    } else {
+        printf("PASS: hint '%s' not reported as '%s'\n", key, rejected);
+    }
+}
+
+/*
+ * Assert that the info object reports at least one hint, and that every
+ * reported hint has a non-empty value.  Issue #13367 was that
+ * MPI_File_get_info returned zero hints.
+ */
+static inline void finfo_expect_nonempty(finfo_result_t *res, MPI_Info info)
+{
+    int nkeys = 0;
+    int i;
+
+    ++res->checks;
+    if (MPI_SUCCESS != MPI_Info_get_nkeys(info, &nkeys) || nkeys <= 0) {
+        ++res->failures;
+        printf("FAIL: MPI_File_get_info returned %d hints, expected at least 1\n",
+               nkeys);
+        return;
+    }
+    printf("PASS: MPI_File_get_info returned %d hint(s)\n", nkeys);
+
+    for (i = 0; i < nkeys; ++i) {
+        char key[MPI_MAX_INFO_KEY + 1];
+        char value[MPI_MAX_INFO_VAL + 1];
+
+        ++res->checks;
+        if (MPI_SUCCESS != MPI_Info_get_nthkey(info, i, key)) {
+            ++res->failures;
+            printf("FAIL: MPI_Info_get_nthkey(%d) failed\n", i);
+            continue;
+        }
+        if (!finfo_info_get(info, key, value) || '\0' == value[0]) {
+            ++res->failures;
+            printf("FAIL: reported hint '%s' has an empty value\n", key);
+        } else {
+            printf("PASS: reported hint '%s' = '%s'\n", key, value);
+        }
+    }
+}
+
+/*
+ * Build a unique, single-process scratch filename.  The pid keeps
+ * concurrent test programs (and any accidental multi-rank launch) from
+ * colliding.  The file itself is always opened MPI_MODE_DELETE_ON_CLOSE.
+ */
+static inline void finfo_make_filename(char *buf, size_t buflen, const char *tag)
+{
+    const char *dir = getenv("TMPDIR");
+
+    if (NULL == dir || '\0' == dir[0]) {
+        dir = "/tmp";
+    }
+    snprintf(buf, buflen, "%s/ompio-file-info-%s-%ld.dat",
+             dir, tag, (long) getpid());
+}
+
+/*
+ * Open a scratch file on MPI_COMM_SELF for read/write, creating it and
+ * arranging for it to be removed on close.  Returns the MPI_File_open
+ * return code; on success the file uses MPI_ERRORS_RETURN.
+ */
+static inline int finfo_open(MPI_File *fh, const char *filename, MPI_Info info)
+{
+    int rc = MPI_File_open(MPI_COMM_SELF, filename,
+                           MPI_MODE_CREATE | MPI_MODE_RDWR
+                           | MPI_MODE_DELETE_ON_CLOSE,
+                           info, fh);
+    if (MPI_SUCCESS == rc) {
+        MPI_File_set_errhandler(*fh, MPI_ERRORS_RETURN);
+    }
+    return rc;
+}
+
+/* Print the final result line and return the process exit status. */
+static inline int finfo_finish(const char *name, const finfo_result_t *res)
+{
+    if (0 == res->failures) {
+        printf("%s: all %d check(s) passed\n", name, res->checks);
+        return EXIT_SUCCESS;
+    }
+    printf("%s: %d of %d check(s) failed\n", name, res->failures, res->checks);
+    return EXIT_FAILURE;
+}
+
+#endif /* OMPIO_FILE_INFO_COMMON_H */
diff --git a/ompi/test/general/Makefile.am b/ompi/test/general/Makefile.am
new file mode 100644
index 00000000000..3ec643ca0a8
--- /dev/null
+++ b/ompi/test/general/Makefile.am
@@ -0,0 +1,228 @@
+#
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+# General unit tests for the OMPI layer (ompi/* top-level directories).
+# Sibling directories under ompi/test/ are named for the single MPI
+# object or interface that they exercise; this one is the catch-all, with
+# one test program per OMPI-layer module.  Each test is a self-checking
+# single-process program (no launcher required) that reports through the
+# local harness in support.c.
+#
+
+# Nearly every test here calls MPI_Init(), and the file test additionally
+# opens an MPI_File (io/ompio, which depends on libmca_common_ompio).
+# Make "make check" work in an uninstalled --enable-mca-dso build tree.
+include $(top_srcdir)/Makefile.mca-dso-check
+
+# A self-contained copy of the test/support harness so that these tests
+# do not depend on the top-level test/ tree.
+EXTRA_DIST = README.md attr_interlang_source.F90 values-f.h
+
+check_LIBRARIES = libompitest_support.a
+libompitest_support_a_SOURCES = support.c support.h
+
+# NOTE: test program names must avoid Automake's built-in recursive
+# target names (info, dvi, ps, pdf, html, tags, check, ...).  The
+# ompi/info test is therefore named "info_t" rather than "info".
+check_PROGRAMS = \
+	info_t \
+	seq_tracker \
+	mpi_init \
+	op \
+	datatype \
+	communicator \
+	proc \
+	group \
+	attribute \
+	errhandler \
+	info_mpi \
+	request \
+	win \
+	win_notify \
+	win_notify_unsupported \
+	instance \
+	file \
+	message
+
+TESTS = $(check_PROGRAMS)
+
+# Common link line for OMPI-level unit tests: libmpi pulls in the OMPI
+# layer, which in turn depends on libopen-pal.
+ompi_test_ldadd = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
+        libompitest_support.a
+
+info_t_SOURCES = info.c
+info_t_LDADD = $(ompi_test_ldadd)
+info_t_DEPENDENCIES = $(ompi_test_ldadd)
+
+seq_tracker_SOURCES = seq_tracker.c
+seq_tracker_LDADD = $(ompi_test_ldadd)
+seq_tracker_DEPENDENCIES = $(ompi_test_ldadd)
+
+mpi_init_SOURCES = mpi_init.c
+mpi_init_LDADD = $(ompi_test_ldadd)
+mpi_init_DEPENDENCIES = $(ompi_test_ldadd)
+
+op_SOURCES = op.c
+op_LDADD = $(ompi_test_ldadd)
+op_DEPENDENCIES = $(ompi_test_ldadd)
+
+datatype_SOURCES = datatype.c
+datatype_LDADD = $(ompi_test_ldadd)
+datatype_DEPENDENCIES = $(ompi_test_ldadd)
+
+communicator_SOURCES = communicator.c
+communicator_LDADD = $(ompi_test_ldadd)
+communicator_DEPENDENCIES = $(ompi_test_ldadd)
+
+proc_SOURCES = proc.c
+proc_LDADD = $(ompi_test_ldadd)
+proc_DEPENDENCIES = $(ompi_test_ldadd)
+
+group_SOURCES = group.c
+group_LDADD = $(ompi_test_ldadd)
+group_DEPENDENCIES = $(ompi_test_ldadd)
+
+attribute_SOURCES = attribute.c
+attribute_LDADD = $(ompi_test_ldadd)
+attribute_DEPENDENCIES = $(ompi_test_ldadd)
+
+errhandler_SOURCES = errhandler.c
+errhandler_LDADD = $(ompi_test_ldadd)
+errhandler_DEPENDENCIES = $(ompi_test_ldadd)
+
+info_mpi_SOURCES = info_mpi.c
+info_mpi_LDADD = $(ompi_test_ldadd)
+info_mpi_DEPENDENCIES = $(ompi_test_ldadd)
+
+request_SOURCES = request.c
+request_LDADD = $(ompi_test_ldadd)
+request_DEPENDENCIES = $(ompi_test_ldadd)
+
+win_SOURCES = win.c
+win_LDADD = $(ompi_test_ldadd)
+win_DEPENDENCIES = $(ompi_test_ldadd)
+
+win_notify_SOURCES = win_notify.c
+win_notify_LDADD = $(ompi_test_ldadd)
+win_notify_DEPENDENCIES = $(ompi_test_ldadd)
+
+win_notify_unsupported_SOURCES = win_notify_unsupported.c
+win_notify_unsupported_LDADD = $(ompi_test_ldadd)
+win_notify_unsupported_DEPENDENCIES = $(ompi_test_ldadd)
+
+instance_SOURCES = instance.c
+instance_LDADD = $(ompi_test_ldadd)
+instance_DEPENDENCIES = $(ompi_test_ldadd)
+
+file_SOURCES = file.c
+file_LDADD = $(ompi_test_ldadd)
+file_DEPENDENCIES = $(ompi_test_ldadd)
+
+message_SOURCES = message.c
+message_LDADD = $(ompi_test_ldadd)
+message_DEPENDENCIES = $(ompi_test_ldadd)
+
+# The Fortran attribute test drives the Fortran attribute back-end
+# (ompi_attr_create_keyval_fint / set_fint / get_fint), which is only
+# reachable through the mpif.h bindings.  Build it only when those
+# bindings are present.
+# --------------------------------------------------------------------------
+# C <-> Fortran attribute interlanguage test.  Ported from
+# open-mpi/ompi-tests simple/attr: a Fortran driver
+# (attr_interlang_source.F90, a template) plus a shared C back-end
+# (attr_interlang.c) exhaustively exercise the 9 cases of setting an
+# attribute in one language and reading it in another (C, Fortran MPI-1
+# default-INTEGER, Fortran MPI-2 address-kind), for communicators,
+# datatypes, and windows.  Single process (MPI_COMM_SELF / MPI_INTEGER /
+# a local window).  Built in all three Fortran flavors, each generated
+# from the template by sed.  (The C back-end uses deprecated MPI-1
+# attribute calls on purpose; it silences the deprecation warnings itself,
+# after including ompi_config.h, rather than via a -D here.)
+# --------------------------------------------------------------------------
+# Empty, but kept so the shared attr_interlang.c object is named
+# per-program (each flavor compiles it with its own Fortran flags).
+attr_interlang_cppflags =
+# Fortran INCLUDE path: generated mpif.h (build tree) + its mpif-*.h
+# fragments (source tree) + values-f.h (this directory).
+attr_interlang_fcflags = -I$(top_builddir)/ompi/include \
+	-I$(top_srcdir)/ompi/include -I$(srcdir)
+
+CLEANFILES = attr_interlang_mpifh.f90 attr_interlang_usempi.f90 \
+	attr_interlang_usempif08.f90
+
+if OMPI_BUILD_FORTRAN_MPIFH_BINDINGS
+check_PROGRAMS += attr_interlang_mpifh
+attr_interlang_mpifh_SOURCES = attr_interlang.c
+nodist_attr_interlang_mpifh_SOURCES = attr_interlang_mpifh.f90
+attr_interlang_mpifh_CPPFLAGS = $(attr_interlang_cppflags)
+attr_interlang_mpifh_FCFLAGS = $(attr_interlang_fcflags)
+attr_interlang_mpifh_LDADD = \
+	$(top_builddir)/ompi/mpi/fortran/mpif-h/libmpi_mpifh.la \
+	$(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+attr_interlang_mpifh_DEPENDENCIES = $(attr_interlang_mpifh_LDADD)
+attr_interlang_mpifh.f90: $(srcdir)/attr_interlang_source.F90
+	$(AM_V_GEN)rm -f $@; sed \
+	  -e 's/FORTRAN_SUB_LINE1/implicit none/g' \
+	  -e 's@FORTRAN_SUB_LINE2@include "mpif.h"@g' \
+	  -e 's/FORTRAN_[A-Z]*_TYPE/integer/g' \
+	  $(srcdir)/attr_interlang_source.F90 > $@
+endif
+
+if OMPI_BUILD_FORTRAN_USEMPI_IGNORE_TKR_BINDINGS
+check_PROGRAMS += attr_interlang_usempi
+attr_interlang_usempi_SOURCES = attr_interlang.c
+nodist_attr_interlang_usempi_SOURCES = attr_interlang_usempi.f90
+attr_interlang_usempi_CPPFLAGS = $(attr_interlang_cppflags)
+attr_interlang_usempi_FCFLAGS = $(attr_interlang_fcflags) \
+	-I$(top_builddir)/ompi/mpi/fortran/use-mpi-ignore-tkr
+attr_interlang_usempi_LDADD = \
+	$(top_builddir)/ompi/mpi/fortran/use-mpi-ignore-tkr/libmpi_usempi_ignore_tkr.la \
+	$(top_builddir)/ompi/mpi/fortran/mpif-h/libmpi_mpifh.la \
+	$(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+attr_interlang_usempi_DEPENDENCIES = $(attr_interlang_usempi_LDADD)
+attr_interlang_usempi.f90: $(srcdir)/attr_interlang_source.F90
+	$(AM_V_GEN)rm -f $@; sed \
+	  -e 's/FORTRAN_SUB_LINE1/use mpi/g' \
+	  -e 's/FORTRAN_SUB_LINE2/implicit none/g' \
+	  -e 's/FORTRAN_[A-Z]*_TYPE/integer/g' \
+	  $(srcdir)/attr_interlang_source.F90 > $@
+endif
+
+if OMPI_BUILD_FORTRAN_USEMPIF08_BINDINGS
+check_PROGRAMS += attr_interlang_usempif08
+attr_interlang_usempif08_SOURCES = attr_interlang.c
+nodist_attr_interlang_usempif08_SOURCES = attr_interlang_usempif08.f90
+attr_interlang_usempif08_CPPFLAGS = $(attr_interlang_cppflags)
+attr_interlang_usempif08_FCFLAGS = $(attr_interlang_fcflags) \
+	-I$(top_builddir)/ompi/mpi/fortran/use-mpi-f08
+attr_interlang_usempif08_LDADD = \
+	$(top_builddir)/ompi/mpi/fortran/use-mpi-f08/libmpi_usempif08.la \
+	$(top_builddir)/ompi/mpi/fortran/use-mpi-ignore-tkr/libmpi_usempi_ignore_tkr.la \
+	$(top_builddir)/ompi/mpi/fortran/mpif-h/libmpi_mpifh.la \
+	$(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+attr_interlang_usempif08_DEPENDENCIES = $(attr_interlang_usempif08_LDADD)
+attr_interlang_usempif08.f90: $(srcdir)/attr_interlang_source.F90
+	$(AM_V_GEN)rm -f $@; sed \
+	  -e 's/FORTRAN_SUB_LINE1/use mpi_f08/g' \
+	  -e 's/FORTRAN_SUB_LINE2/implicit none/g' \
+	  -e 's/FORTRAN_COMM_TYPE/type(MPI_Comm)/g' \
+	  -e 's/FORTRAN_WIN_TYPE/type(MPI_Win)/g' \
+	  -e 's/FORTRAN_DATATYPE_TYPE/type(MPI_Datatype)/g' \
+	  -e 's/MPI_NULL_COPY_FN/MPI_COMM_NULL_COPY_FN/g' \
+	  -e 's/MPI_NULL_DELETE_FN/MPI_COMM_NULL_DELETE_FN/g' \
+	  $(srcdir)/attr_interlang_source.F90 > $@
+endif
+
+distclean-local:
+	rm -rf *.dSYM .deps .libs *.log *.o *.trs $(check_PROGRAMS) Makefile
diff --git a/ompi/test/general/README.md b/ompi/test/general/README.md
new file mode 100644
index 00000000000..713a9a822d2
--- /dev/null
+++ b/ompi/test/general/README.md
@@ -0,0 +1,191 @@
+# General OMPI layer unit tests (`ompi/test/general/`)
+
+Single-process unit tests for the OMPI layer (the top-level `ompi/*`
+directories other than `mca`, `mpi`, `mpiext`, and `peruse`).  The tests
+live entirely within the `ompi/` subtree and carry their own copy of the
+test harness (`support.{c,h}`).
+
+This is the catch-all directory: sibling directories under `ompi/test/`
+are named for the single MPI object or interface that they exercise
+(`t/` for MPI_T, `file/` for MPI_File info hints, `datatype/` for the
+datatype engine), while `general/` covers everything else -- one test
+program per OMPI-layer module.
+
+## Running
+
+From a configured build directory:
+
+```sh
+make -C ompi all                  # build libmpi (tests link against it)
+make -C ompi/test check           # build + run all OMPI unit tests
+make -C ompi/test/general check   # ...or just the general ones
+```
+
+Every test is a self-checking program that reports through the harness
+(`test_init` / `test_verify` / `test_finalize`) and is wired into the
+Automake `TESTS` list.  Note: the library is built with `-DNDEBUG`, so
+`assert()` is a no-op in the tested code -- all verification goes through
+`test_verify()`.
+
+## Scope: single process only
+
+By design these tests run in a single process (no `mpirun`/`mpiexec`).
+They use one of two initialization styles:
+
+- **partial init** -- `opal_init_util()` plus the relevant OMPI subsystem
+  init (e.g. `ompi_mpiinfo_init()`); fast, no runtime bring-up.
+- **full singleton `MPI_Init`** -- brings up the runtime in singleton
+  mode (~0.1s, no launcher); used for anything needing live MPI state.
+
+Multi-process (`np>1`) behavior is intentionally **out of scope here** and
+is left to a separate follow-up effort.  The areas that require `np>1`
+are catalogued below so that follow-up effort can target them directly.
+
+## Coverage summary (single process, Linux gcov, line %)
+
+| Directory | Coverage | Notes |
+|-----------|---------:|-------|
+| message     | 96% | |
+| op          | 91% | |
+| file        | 84% | full MPI-IO lifecycle on `MPI_COMM_SELF` (ompio) |
+| class       | 84% | `ompi_seq_tracker` |
+| win         | 79% | window lifecycle; RMA data movement is np>1 |
+| interlib    | 78% | |
+| attribute   | 82% | C + Fortran (mpif-h/use-mpi/use-mpi-f08) incl. C<->Fortran interlanguage |
+| info        | 66% | |
+| datatype    | 64% | constructors high; serialization cross-arch is np>1 |
+| errhandler  | 56% | errcode 80-99%; fatal handlers + invoke need runtime |
+| instance    | 50% | Sessions; PMIx-server paths are np>1 |
+| proc        | 49% | proc table is populated by the np>1 modex |
+| request     | 46% | generalized requests high; p2p completion is np>1 |
+| group       | 39% | dense ops covered; sparse reps need large/np>1 groups |
+| runtime     | 36% | init covered; finalize/error/SPC paths thin |
+| communicator| 24% | most paths are collective/CID/FT, i.e. np>1 |
+| dpm         |  3% | dynamic process management is inherently np>1 |
+| debuggers   |  0% | TotalView DLL, driven by debugger callbacks |
+
+`tools/` (mpirun, ompi_info, mpisync) are executables rather than a
+library; `etc/`, `util/`, and `include/` contain no or header-only `.c`.
+
+## Areas requiring `np>1` (for the follow-up effort)
+
+The following code paths cannot execute in a single process and account
+for most of the uncovered lines above.
+
+### communicator (`ompi/communicator/`)
+- `comm_cid.c` -- communicator-ID allocation is a collective negotiation
+  over the group; only the singleton fast path runs with one rank.
+- `comm.c` -- the collective-based creation paths (`ompi_comm_split`,
+  `split_type`, `create`, `create_group`, inter-communicator merge/create)
+  past the size-1 short-circuit; remote-group handling for
+  inter-communicators.
+- `comm_request.c` -- the nonblocking comm-creation state machine
+  (`MPI_Comm_idup` and friends) requires progressing collectives.
+- `comm_ft.c`, `comm_ft_detector.c`, `comm_ft_propagator.c`,
+  `comm_ft_reliable_bcast.c`, `comm_ft_revoke.c` -- ULFM fault tolerance;
+  entirely multi-rank (failure detection/propagation/revocation).
+
+### proc (`ompi/proc/`)
+- `ompi_proc_complete_init` and the proc-table population from the PMIx
+  modex; `ompi_proc_for_name` on-demand creation of remote procs.  With
+  one rank only the local proc exists.
+
+### group (`ompi/group/`)
+- `group_bitmap.c`, `group_strided.c`, `group_sporadic.c` -- the sparse
+  group representations are only chosen for large (multi-rank) groups; a
+  singleton always uses the dense representation.  Their
+  translate/incl/excl/range implementations need a multi-rank parent.
+
+### datatype (`ompi/datatype/`)
+- `ompi_datatype_args.c` -- the cross-architecture branches of
+  `__ompi_datatype_create_from_args` / pack-description (byte-swap and
+  size conversion) only run when the remote proc has a different
+  architecture.  The same-architecture round-trip *is* covered.
+- `ompi_datatype_sndrcv.c` -- the internal send/recv helper needs an
+  actual peer.
+
+### request (`ompi/request/`)
+- `req_wait.c`, `req_test.c` -- the point-to-point completion paths
+  (waiting/testing on pending sends/receives) need a peer to make
+  progress; only generalized-request and NULL-request paths run here.
+- `req_ft.c` -- fault-tolerant request handling (multi-rank).
+
+### instance (`ompi/instance/`)
+- `MPI_Comm_create_from_group` and other operations that perform a
+  PMIx-server-backed collective (CID allocation over a pset) fail with
+  "PMIx server unreachable" in a launcher-less singleton.
+- Multi-pset / dynamic-pset and PMIx-event-driven paths.
+
+### errhandler (`ompi/errhandler/`)
+- `errhandler_predefined.c` -- the `MPI_ERRORS_ARE_FATAL` /
+  `MPI_ERRORS_ABORT` handlers call `ompi_mpi_abort()` and cannot be
+  invoked in a passing test; only `MPI_ERRORS_RETURN` and custom handlers
+  (via `*_call_errhandler`) are exercised.
+- `errhandler_invoke.c` -- some object-type dispatch paths exercised only
+  by real error conditions during communication.
+
+### dpm (`ompi/dpm/`)
+- Essentially all of `dpm.c`: `MPI_Comm_spawn[_multiple]`,
+  `MPI_Comm_connect`/`accept`/`join`, and name publishing/lookup require
+  a runtime with a launcher and/or multiple jobs.
+
+### info (`ompi/info/`)
+- `ompi_info_memkind_copy_or_set` and `..._validate` run during object
+  creation only when `mpi_memory_alloc_kinds` is set (an MCA parameter);
+  the parser (`ompi_info_memkind_process`) is covered directly.
+
+### runtime (`ompi/runtime/`)
+- Most of `ompi_mpi_init`/`finalize` is covered, but error/teardown
+  branches, the SPC (software performance counter) reporting, and
+  multi-threaded paths are not exercised single-process.
+
+## Other (non-`np>1`) ceilings
+
+- **MPI-IO in restricted/sandboxed environments**: the `file` test runs
+  the full MPI-IO lifecycle and is expected to pass on Linux and macOS.
+  In a restricted/sandboxed environment (e.g. some LLM coding harnesses),
+  notably on macOS, it can fail at `MPI_File_open` because ompio's default
+  shared-file-pointer component, `sm`, cannot create the POSIX named
+  semaphore it needs (`sem_open` returns `EPERM`).  This is an environment
+  limitation, not an Open MPI bug; the test fails (it does not skip) and
+  prints a hint suggesting a re-run with `OMPI_MCA_sharedfp=^sm` to
+  confirm the cause.
+- **attribute (Fortran + interlanguage)**: `attribute.c` is at ~82%,
+  covered by the C `attribute` test plus `attr_interlang`, a port of
+  open-mpi/ompi-tests `simple/attr`.  `attr_interlang` is built in all
+  three Fortran flavors (`attr_interlang_mpifh`, `_usempi`, `_usempif08`)
+  from one template, and exhaustively exercises the 9 cases of setting an
+  attribute in one language and reading it in another -- C, Fortran MPI-1
+  (default INTEGER), and Fortran MPI-2 (address kind) -- for
+  communicators, datatypes, and windows.  This covers the cross-language
+  translation (`translate_to_fint`/`_aint`/`_c`).  The residual is
+  error/out-of-resource/`abort()` paths only (not reachable in a passing
+  single-process test).
+- **debuggers**: `ompi_debuggers.c`, `ompi_common_dll.c`, and
+  `ompi_msgq_dll.c` are the TotalView message-queue DLL, driven by
+  debugger-supplied memory-read callbacks (`mqs_*`).  They cannot be
+  exercised without a debugger (or a mock of the callback interface).  The
+  existing `predefined_gap/pad` and `dlopen` checks validate object
+  padding and DSO loadability, not this code.
+
+## Bug found while writing these tests
+
+`MPI_Type_get_contents` (and the large-count `MPI_Type_get_contents_c`)
+iterated over the caller-provided `max_datatypes` capacity rather than the
+actual number of constituent datatypes, dereferencing uninitialized
+handles and segfaulting on standard-conforming code that passes oversized
+output arrays.  Fixed in `ompi/mpi/c/type_get_contents.c` and
+`type_get_contents_c.c` (separate commit from the tests).
+
+## Adding a test
+
+1. Write `ompi/test/general/<module>.c` (include `"support.h"`; pick partial or
+   full init).  Avoid Automake's reserved target names (`info`, `dvi`,
+   `ps`, `pdf`, `html`, ...) for the program name -- e.g. the `ompi/info`
+   test program is `info_t`.
+2. Add it to `check_PROGRAMS` and the per-program `_SOURCES`/`_LDADD`/
+   `_DEPENDENCIES` (use `$(ompi_test_ldadd)`) in `Makefile.am`.
+3. Editing only `Makefile.am` does **not** require `autogen.pl`; a plain
+   `make` regenerates `Makefile.in`.  (Adding a brand-new registered
+   Makefile, or editing `config/*.m4`, does require `./autogen.pl` +
+   reconfigure.)
diff --git a/ompi/test/general/attr_interlang.c b/ompi/test/general/attr_interlang.c
new file mode 100644
index 00000000000..274dae179a6
--- /dev/null
+++ b/ompi/test/general/attr_interlang.c
@@ -0,0 +1,678 @@
+/*
+ * Copyright (c) 2012      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * C back-end for the C<->Fortran attribute interlanguage test.  Adapted
+ * from the open-mpi/ompi-tests simple/attr test (attr_c.c) for the
+ * in-tree ompi/test suite.  Provides keyval-create / write / read / check
+ * helpers that the Fortran driver calls, so that attributes set in one
+ * language can be read (and value-translated) in the other.
+ */
+
+#include "ompi_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+/* This test intentionally exercises the deprecated MPI-1 attribute
+ * routines (MPI_Keyval_create / MPI_Attr_put / MPI_Attr_get, ...).
+ * ompi_config.h enables the MPI interface-deprecation warnings; turn them
+ * off here (before including mpi.h) so the build stays clean. */
+#undef OMPI_WANT_MPI_INTERFACE_WARNING
+#define OMPI_WANT_MPI_INTERFACE_WARNING 0
+
+#include "mpi.h"
+
+/*
+ * Do not change these values without also changing their
+ * corresponding values in values-f.h!
+ */
+enum { FORTRAN_MPI1_VALUE1 = 771 };
+enum { FORTRAN_MPI1_VALUE2 = -771 };
+enum { FORTRAN_MPI1_VALUE3 = -123 };
+enum { FORTRAN_MPI2_VALUE1 = 772 };
+enum { FORTRAN_MPI2_VALUE2 = -772 };
+enum { FORTRAN_MPI2_VALUE3 = -123 };
+enum { C_VALUE1 = 99 };
+enum { C_VALUE2 = -99 };
+enum { C_VALUE3 = 481 };
+
+
+typedef enum attr_type {
+    INTEGER,
+    AINT
+} attr_type_t;
+
+
+/* Back-end functions */
+static int comm_delete_fn(MPI_Comm comm, int keyval,
+                          void* attribute_val_out,
+                          void* extra_state);
+static int comm_copy_fn(MPI_Comm comm, int keyval,
+                        void* extra_state,
+                        void* attribute_val_in,
+                        void* attribute_val_out,
+                        int* flag);
+static int type_delete_fn(MPI_Datatype type, int keyval,
+                          void* attribute_val_out,
+                          void* extra_state);
+static int type_copy_fn(MPI_Datatype type, int keyval,
+                        void* extra_state,
+                        void* attribute_val_in,
+                        void* attribute_val_out,
+                        int* flag);
+static int win_delete_fn(MPI_Win win, int keyval,
+                         void* attribute_val_out,
+                         void* extra_state);
+static int win_copy_fn(MPI_Win win, int keyval,
+                       void* extra_state,
+                       void* attribute_val_in,
+                       void* attribute_val_out,
+                       int* flag);
+
+static void c_create_keyval_backend(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                                    MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                                    MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                                    MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3);
+static void c_write_backend(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                            MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                            MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                            MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3,
+                            MPI_Fint *win);
+static void c_read_backend(MPI_Fint *k1, MPI_Fint *k2,
+                           MPI_Fint *kc1, MPI_Fint *kc2,
+                           MPI_Fint *kt1, MPI_Fint *kt2,
+                           MPI_Fint *kw1, MPI_Fint *kw2,
+                           MPI_Fint *f11, MPI_Fint *f12, MPI_Fint *f13,
+                           MPI_Fint *fc21, MPI_Fint *fc22, MPI_Fint *fc23,
+                           MPI_Fint *ft21, MPI_Fint *ft22, MPI_Fint *ft23,
+                           MPI_Fint *fw21, MPI_Fint *fw22, MPI_Fint *fw23,
+                           MPI_Fint *win);
+static void c_check_mpi1_backend(MPI_Fint *key, MPI_Fint *value);
+static void c_check_mpi2_backend(MPI_Fint *key, MPI_Aint *value);
+
+static void check(int key, int expected_value, attr_type_t type);
+static void check_comm(int key, int expected_value, attr_type_t type);
+static void check_type(int key, int expected_value, attr_type_t type);
+static void check_win(MPI_Win win, int key, int expected_value, attr_type_t type);
+
+/* Fortran wrappers */
+void c_create_keyval(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                     MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                     MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                     MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3)
+{ c_create_keyval_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3); }
+void c_create_keyval_(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                      MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                      MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                      MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3)
+{ c_create_keyval_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3); }
+void c_create_keyval__(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                       MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                       MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                       MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3)
+{ c_create_keyval_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3); }
+void C_CREATE_KEYVAL(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                     MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                     MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                     MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3)
+{ c_create_keyval_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3); }
+
+
+void c_write(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+             MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+             MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+             MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3,
+             MPI_Fint *win)
+{ c_write_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3, win); }
+void c_write_(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+              MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+              MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+              MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3,
+              MPI_Fint *win)
+{ c_write_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3, win); }
+void c_write__(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+               MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+               MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+               MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3,
+               MPI_Fint *win)
+{ c_write_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3, win); }
+void C_WRITE(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+             MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+             MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+             MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3,
+             MPI_Fint *win)
+{ c_write_backend(k1, k2, k3, kc1, kc2, kc3, kt1, kt2, kt3, kw1, kw2, kw3, win); }
+
+void c_read(MPI_Fint *k1, MPI_Fint *k2,
+            MPI_Fint *kc1, MPI_Fint *kc2,
+            MPI_Fint *kt1, MPI_Fint *kt2,
+            MPI_Fint *kw1, MPI_Fint *kw2,
+            MPI_Fint *f11, MPI_Fint *f12, MPI_Fint *f13,
+            MPI_Fint *fc21, MPI_Fint *fc22, MPI_Fint *fc23,
+            MPI_Fint *ft21, MPI_Fint *ft22, MPI_Fint *ft23,
+            MPI_Fint *fw21, MPI_Fint *fw22, MPI_Fint *fw23,
+            MPI_Fint *win)
+{ c_read_backend(k1, k2, kc1, kc2, kt1, kt2, kw1, kw2,
+                 f11, f12, f13,
+                 fc21, fc22, fc23, ft21, ft22, ft23, fw21, fw22, fw23, win); }
+void c_read_(MPI_Fint *k1, MPI_Fint *k2,
+             MPI_Fint *kc1, MPI_Fint *kc2,
+             MPI_Fint *kt1, MPI_Fint *kt2,
+             MPI_Fint *kw1, MPI_Fint *kw2,
+             MPI_Fint *f11, MPI_Fint *f12, MPI_Fint *f13,
+             MPI_Fint *fc21, MPI_Fint *fc22, MPI_Fint *fc23,
+             MPI_Fint *ft21, MPI_Fint *ft22, MPI_Fint *ft23,
+             MPI_Fint *fw21, MPI_Fint *fw22, MPI_Fint *fw23,
+             MPI_Fint *win)
+{ c_read_backend(k1, k2, kc1, kc2, kt1, kt2, kw1, kw2,
+                 f11, f12, f13,
+                 fc21, fc22, fc23, ft21, ft22, ft23, fw21, fw22, fw23, win); }
+void c_read__(MPI_Fint *k1, MPI_Fint *k2,
+              MPI_Fint *kc1, MPI_Fint *kc2,
+              MPI_Fint *kt1, MPI_Fint *kt2,
+              MPI_Fint *kw1, MPI_Fint *kw2,
+              MPI_Fint *f11, MPI_Fint *f12, MPI_Fint *f13,
+              MPI_Fint *fc21, MPI_Fint *fc22, MPI_Fint *fc23,
+              MPI_Fint *ft21, MPI_Fint *ft22, MPI_Fint *ft23,
+              MPI_Fint *fw21, MPI_Fint *fw22, MPI_Fint *fw23,
+              MPI_Fint *win)
+{ c_read_backend(k1, k2, kc1, kc2, kt1, kt2, kw1, kw2,
+                 f11, f12, f13,
+                 fc21, fc22, fc23, ft21, ft22, ft23, fw21, fw22, fw23, win); }
+void C_READ(MPI_Fint *k1, MPI_Fint *k2,
+            MPI_Fint *kc1, MPI_Fint *kc2,
+            MPI_Fint *kt1, MPI_Fint *kt2,
+            MPI_Fint *kw1, MPI_Fint *kw2,
+            MPI_Fint *f11, MPI_Fint *f12, MPI_Fint *f13,
+            MPI_Fint *fc21, MPI_Fint *fc22, MPI_Fint *fc23,
+            MPI_Fint *ft21, MPI_Fint *ft22, MPI_Fint *ft23,
+            MPI_Fint *fw21, MPI_Fint *fw22, MPI_Fint *fw23,
+            MPI_Fint *win)
+{ c_read_backend(k1, k2, kc1, kc2, kt1, kt2, kw1, kw2,
+                 f11, f12, f13,
+                 fc21, fc22, fc23, ft21, ft22, ft23, fw21, fw22, fw23, win); }
+
+void c_check_mpi1(MPI_Fint *key, MPI_Fint *value)
+{ c_check_mpi1_backend(key, value); }
+void c_check_mpi1_(MPI_Fint *key, MPI_Fint *value)
+{ c_check_mpi1_backend(key, value); }
+void c_check_mpi1__(MPI_Fint *key, MPI_Fint *value)
+{ c_check_mpi1_backend(key, value); }
+void C_CHECK_MPI1(MPI_Fint *key, MPI_Fint *value)
+{ c_check_mpi1_backend(key, value); }
+
+void c_check_mpi2(MPI_Fint *key, MPI_Aint *value)
+{ c_check_mpi2_backend(key, value); }
+void c_check_mpi2_(MPI_Fint *key, MPI_Aint *value)
+{ c_check_mpi2_backend(key, value); }
+void c_check_mpi2__(MPI_Fint *key, MPI_Aint *value)
+{ c_check_mpi2_backend(key, value); }
+void C_CHECK_MPI2(MPI_Fint *key, MPI_Aint *value)
+{ c_check_mpi2_backend(key, value); }
+
+/* keyval storage */
+static int c_keyval1;
+static int c_keyval2;
+static int c_keyval3;
+static int c_comm_keyval1;
+static int c_comm_keyval2;
+static int c_comm_keyval3;
+static int c_type_keyval1;
+static int c_type_keyval2;
+static int c_type_keyval3;
+static int c_win_keyval1;
+static int c_win_keyval2;
+static int c_win_keyval3;
+
+/* attribute storage */
+static int c_value1 = C_VALUE1;
+static int c_value2 = C_VALUE2;
+static int c_value3 = C_VALUE3;
+static int f_mpi1_value1 = FORTRAN_MPI1_VALUE1;
+static int f_mpi1_value2 = FORTRAN_MPI1_VALUE2;
+static int f_mpi1_value3 = FORTRAN_MPI1_VALUE3;
+static int f_mpi2_value1 = FORTRAN_MPI2_VALUE1;
+static int f_mpi2_value2 = FORTRAN_MPI2_VALUE2;
+static int f_mpi2_value3 = FORTRAN_MPI2_VALUE3;
+
+/************************************************************************/
+
+static int comm_delete_fn(MPI_Comm comm, int keyval,
+                          void* attribute_val_out,
+                          void* extra_state)
+{
+    printf("In C comm delete function\n");
+    return MPI_SUCCESS;
+}
+
+static int comm_copy_fn(MPI_Comm comm, int keyval,
+                        void* extra_state,
+                        void* attribute_val_in,
+                        void* attribute_val_out,
+                        int* flag)
+{
+    printf("In C comm copy function\n");
+    *flag = 1;
+   *(void**)attribute_val_out = attribute_val_in;
+    return MPI_SUCCESS;
+}
+
+static int type_delete_fn(MPI_Datatype type, int keyval,
+                          void* attribute_val_out,
+                          void* extra_state)
+{
+    printf("In C datatype delete function\n");
+    return MPI_SUCCESS;
+}
+
+static int type_copy_fn(MPI_Datatype type, int keyval,
+                        void* extra_state,
+                        void* attribute_val_in,
+                        void* attribute_val_out,
+                        int* flag)
+{
+    printf("In C datatype copy function\n");
+    *flag = 1;
+   *(void**)attribute_val_out = attribute_val_in;
+    return MPI_SUCCESS;
+}
+
+
+static int win_delete_fn(MPI_Win win, int keyval,
+                         void* attribute_val_out,
+                         void* extra_state)
+{
+    printf("In C win delete function\n");
+    return MPI_SUCCESS;
+}
+
+static int win_copy_fn(MPI_Win win, int keyval,
+                       void* extra_state,
+                       void* attribute_val_in,
+                       void* attribute_val_out,
+                       int* flag)
+{
+    printf("In C win copy function\n");
+    *flag = 1;
+   *(void**)attribute_val_out = attribute_val_in;
+    return MPI_SUCCESS;
+}
+
+
+/************************************************************************/
+
+static void c_create_keyval_backend(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                                    MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                                    MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                                    MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3)
+{
+    int key;
+
+    printf("Creating C keyval 1\n");
+    MPI_Keyval_create(comm_copy_fn, comm_delete_fn, &key, NULL);
+    c_keyval1 = key;
+    *k1 = (MPI_Fint) key;
+    printf("Created C keyval 1: %d\n", key);
+
+    printf("Creating C keyval 2\n");
+    MPI_Keyval_create(comm_copy_fn, comm_delete_fn, &key, NULL);
+    c_keyval2 = key;
+    *k2 = (MPI_Fint) key;
+    printf("Created C keyval 2: %d\n", key);
+
+    printf("Creating C keyval 3\n");
+    MPI_Keyval_create(MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &key, NULL);
+    c_keyval3 = key;
+    *k3 = (MPI_Fint) key;
+    printf("Created C keyval 3: %d\n", key);
+
+    /***********************/
+
+    printf("Creating C comm keyval 1\n");
+    MPI_Comm_create_keyval(comm_copy_fn, comm_delete_fn, &key, NULL);
+    c_comm_keyval1 = key;
+    *kc1 = (MPI_Fint) key;
+    printf("Created C comm keyval 1: %d\n", key);
+
+    printf("Creating C comm keyval 2\n");
+    MPI_Comm_create_keyval(comm_copy_fn, comm_delete_fn, &key, NULL);
+    c_comm_keyval2 = key;
+    *kc2 = (MPI_Fint) key;
+    printf("Created C comm keyval 2: %d\n", key);
+
+    printf("Creating C comm keyval 3\n");
+    MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN, MPI_COMM_NULL_DELETE_FN,
+                           &key, NULL);
+    c_comm_keyval3 = key;
+    *kc3 = (MPI_Fint) key;
+    printf("Created C comm keyval 3: %d\n", key);
+
+    /***********************/
+
+    printf("Creating C type keyval 1\n");
+    MPI_Type_create_keyval(type_copy_fn, type_delete_fn, &key, NULL);
+    c_type_keyval1 = key;
+    *kt1 = (MPI_Fint) key;
+    printf("Created C type keyval 1: %d\n", key);
+
+    printf("Creating C type keyval 2\n");
+    MPI_Type_create_keyval(type_copy_fn, type_delete_fn, &key, NULL);
+    c_type_keyval2 = key;
+    *kt2 = (MPI_Fint) key;
+    printf("Created C type keyval 2: %d\n", key);
+
+    printf("Creating C type keyval 3\n");
+    MPI_Type_create_keyval(MPI_TYPE_NULL_COPY_FN, MPI_TYPE_NULL_DELETE_FN,
+                           &key, NULL);
+    c_type_keyval3 = key;
+    *kt3 = (MPI_Fint) key;
+    printf("Created C type keyval 3: %d\n", key);
+
+    /***********************/
+
+    printf("Creating C win keyval 1\n");
+    MPI_Win_create_keyval(win_copy_fn, win_delete_fn, &key, NULL);
+    c_win_keyval1 = key;
+    *kw1 = (MPI_Fint) key;
+    printf("Created C win keyval 1: %d\n", key);
+
+    printf("Creating C win keyval 2\n");
+    MPI_Win_create_keyval(win_copy_fn, win_delete_fn, &key, NULL);
+    c_win_keyval2 = key;
+    *kw2 = (MPI_Fint) key;
+    printf("Created C win keyval 2: %d\n", key);
+
+    printf("Creating C win keyval 3\n");
+    MPI_Win_create_keyval(MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN,
+                          &key, NULL);
+    c_win_keyval3 = key;
+    *kw3 = (MPI_Fint) key;
+    printf("Created C win keyval 3: %d\n", key);
+}
+
+/************************************************************************/
+
+static void c_write_backend(MPI_Fint *k1, MPI_Fint *k2, MPI_Fint *k3,
+                            MPI_Fint *kc1, MPI_Fint *kc2, MPI_Fint *kc3,
+                            MPI_Fint *kt1, MPI_Fint *kt2, MPI_Fint *kt3,
+                            MPI_Fint *kw1, MPI_Fint *kw2, MPI_Fint *kw3,
+                            MPI_Fint *win)
+{
+    MPI_Win c_win = MPI_Win_f2c(*win);
+
+    printf("Writing C attr 1: keyval=%d\n", (int) *k1);
+    MPI_Attr_put(MPI_COMM_SELF, (int) *k1, (void*) &c_value1);
+    printf("Writing C attr 2: keyval=%d\n", (int) *k2);
+    MPI_Attr_put(MPI_COMM_SELF, (int) *k2, (void*) &c_value2);
+    printf("Writing C attr 3: keyval=%d\n", (int) *k3);
+    MPI_Attr_put(MPI_COMM_SELF, (int) *k3, (void*) &c_value3);
+
+    printf("Writing C comm attr 1\n");
+    MPI_Comm_set_attr(MPI_COMM_SELF, (int) *kc1, (void*) &c_value1);
+    printf("Writing C comm attr 2\n");
+    MPI_Comm_set_attr(MPI_COMM_SELF, (int) *kc2, (void*) &c_value2);
+    printf("Writing C comm attr 3\n");
+    MPI_Comm_set_attr(MPI_COMM_SELF, (int) *kc3, (void*) &c_value3);
+
+    printf("Writing C type attr 1\n");
+    MPI_Type_set_attr(MPI_INTEGER, (int) *kt1, (void*) &c_value1);
+    printf("Writing C type attr 2\n");
+    MPI_Type_set_attr(MPI_INTEGER, (int) *kt2, (void*) &c_value2);
+    printf("Writing C type attr 3\n");
+    MPI_Type_set_attr(MPI_INTEGER, (int) *kt3, (void*) &c_value3);
+
+    printf("Writing C win attr 1\n");
+    MPI_Win_set_attr(c_win, (int) *kw1, (void*) &c_value1);
+    printf("Writing C win attr 2\n");
+    MPI_Win_set_attr(c_win, (int) *kw2, (void*) &c_value2);
+    printf("Writing C win attr 3\n");
+    MPI_Win_set_attr(c_win, (int) *kw3, (void*) &c_value3);
+}
+
+/************************************************************************/
+
+static void c_read_backend(MPI_Fint *k1, MPI_Fint *k2,
+                           MPI_Fint *kc1, MPI_Fint *kc2,
+                           MPI_Fint *kt1, MPI_Fint *kt2,
+                           MPI_Fint *kw1, MPI_Fint *kw2,
+                           MPI_Fint *f11, MPI_Fint *f12, MPI_Fint *f13,
+                           MPI_Fint *fc21, MPI_Fint *fc22, MPI_Fint *fc23,
+                           MPI_Fint *ft21, MPI_Fint *ft22, MPI_Fint *ft23,
+                           MPI_Fint *fw21, MPI_Fint *fw22, MPI_Fint *fw23,
+                           MPI_Fint *win)
+{
+    MPI_Win c_win = MPI_Win_f2c(*win);
+
+    printf("Case 1: C writes, C reads (MPI-1)\n");
+    check((int) *k1, c_value1, INTEGER);
+    check((int) *k2, c_value2, INTEGER);
+
+    printf("Case 1: C writes, C reads (MPI-2 comm)\n");
+    check_comm((int) *kc1, c_value1, INTEGER);
+    check_comm((int) *kc2, c_value2, INTEGER);
+
+    printf("Case 1: C writes, C reads (MPI-2 type)\n");
+    check_type((int) *kt1, c_value1, INTEGER);
+    check_type((int) *kt2, c_value2, INTEGER);
+
+    printf("Case 1: C writes, C reads (MPI-2 win)\n");
+    check_win(c_win, (int) *kw1, c_value1, INTEGER);
+    check_win(c_win, (int) *kw2, c_value2, INTEGER);
+
+    printf("Case 4: Fortran MPI-1 writes, C reads (MPI-1)\n");
+    check((int) *f11, f_mpi1_value1, INTEGER);
+    check((int) *f12, f_mpi1_value2, INTEGER);
+
+    printf("Case 4: Fortran MPI-1 writes, C reads (MPI-2)\n");
+    check_comm((int) *f11, f_mpi1_value1, INTEGER);
+    check_comm((int) *f12, f_mpi1_value2, INTEGER);
+
+    printf("Case 7: Fortran MPI-2 writes, C reads (MPI-1)\n");
+    check((int) *fc21, f_mpi2_value1, AINT);
+    check((int) *fc22, f_mpi2_value2, AINT);
+
+    printf("Case 7: Fortran MPI-2 writes, C reads (MPI-2 comm)\n");
+    check_comm((int) *fc21, f_mpi2_value1, AINT);
+    check_comm((int) *fc22, f_mpi2_value2, AINT);
+
+    printf("Case 7: Fortran MPI-2 writes, C reads (MPI-2 type)\n");
+    check_type((int) *ft21, f_mpi2_value1, AINT);
+    check_type((int) *ft22, f_mpi2_value2, AINT);
+
+    printf("Case 7: Fortran MPI-2 writes, C reads (MPI-2 win)\n");
+    check_win(c_win, (int) *fw21, f_mpi2_value1, AINT);
+    check_win(c_win, (int) *fw22, f_mpi2_value2, AINT);
+}
+
+static void check(int key, int expected_value, attr_type_t type)
+{
+    int flag;
+    void *value;
+    int *ivalue;
+    MPI_Aint *avalue;
+
+    MPI_Attr_get(MPI_COMM_SELF, key, &value, &flag);
+    if (0 == flag) {
+        printf("ERROR: Reading attribute got flag==0 when expected flag==1\n");
+        exit(-1);
+    }
+    if (INTEGER == type) {
+        ivalue = (int*) value;
+        if (expected_value != *ivalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   *ivalue, expected_value);
+            exit(-1);
+        }
+    } else {
+        avalue = (MPI_Aint*) value;
+        if (expected_value != *avalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   (int) *avalue, expected_value);
+            exit(-1);
+        }
+    }
+}
+
+static void check_comm(int key, int expected_value, attr_type_t type)
+{
+    int flag;
+    void *value;
+    int *ivalue;
+    MPI_Aint *avalue;
+
+    MPI_Comm_get_attr(MPI_COMM_SELF, key, &value, &flag);
+    if (0 == flag) {
+        printf("ERROR: Reading attribute got flag==0 when expected flag==1\n");
+        exit(-1);
+    }
+    if (INTEGER == type) {
+        ivalue = (int*) value;
+        if (expected_value != *ivalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   *ivalue, expected_value);
+            exit(-1);
+        }
+    } else {
+        avalue = (MPI_Aint*) value;
+        if (expected_value != *avalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   (int) *avalue, expected_value);
+            exit(-1);
+        }
+    }
+}
+
+
+static void check_type(int key, int expected_value, attr_type_t type)
+{
+    int flag;
+    void *value;
+    int *ivalue;
+    MPI_Aint *avalue;
+
+    MPI_Type_get_attr(MPI_INTEGER, key, &value, &flag);
+    if (0 == flag) {
+        printf("ERROR: Reading attribute got flag==0 when expected flag==1\n");
+        exit(-1);
+    }
+    if (INTEGER == type) {
+        ivalue = (int*) value;
+        if (expected_value != *ivalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   *ivalue, expected_value);
+            exit(-1);
+        }
+    } else {
+        avalue = (MPI_Aint*) value;
+        if (expected_value != *avalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   (int) *avalue, expected_value);
+            exit(-1);
+        }
+    }
+}
+
+
+static void check_win(MPI_Win win, int key, int expected_value, attr_type_t type)
+{
+    int flag;
+    void *value;
+    int *ivalue;
+    MPI_Aint *avalue;
+
+    MPI_Win_get_attr(win, key, &value, &flag);
+    if (0 == flag) {
+        printf("ERROR: Reading attribute got flag==0 when expected flag==1\n");
+        exit(-1);
+    }
+    if (INTEGER == type) {
+        ivalue = (int*) value;
+        if (expected_value != *ivalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   *ivalue, expected_value);
+            exit(-1);
+        }
+    } else {
+        avalue = (MPI_Aint*) value;
+        if (expected_value != *avalue) {
+            printf("ERROR: Reading attribute got value==%d when expected %d\n",
+                   (int) *avalue, expected_value);
+            exit(-1);
+        }
+    }
+}
+
+
+static void c_check_mpi1_backend(MPI_Fint *key, MPI_Fint *value)
+{
+    int k = (int) *key;
+    int *v;
+    union {
+        void *c_ptr;
+        MPI_Fint f_integer;
+    } xlate;
+
+    if (k == c_keyval1 || k == c_comm_keyval1 || k == c_type_keyval1 || k == c_win_keyval1) {
+        v = &c_value1;
+    } else if (k == c_keyval2 || k == c_comm_keyval2 || k == c_type_keyval2 || k == c_win_keyval2) {
+        v = &c_value2;
+    } else {
+        v = &c_value3;
+    }
+
+    xlate.f_integer = *value;
+    if (sizeof(void*) == sizeof(MPI_Fint)) {
+        if (xlate.c_ptr != v) {
+            printf("Checking MPI-2 C attribute value backend (same size), got value=%x; expected %x\n",
+                   (int)(uintptr_t) xlate.c_ptr, (int)(uintptr_t) v);
+            exit(1);
+        }
+    } else {
+        void *bogus = (void*) 1;
+        MPI_Fint *p = (MPI_Fint*) &bogus;
+        int pos;
+
+        for (pos = 0; pos < (sizeof(void*) / sizeof(MPI_Fint));
+             ++pos) {
+            if (p[pos] == 1) {
+                break;
+            }
+        }
+        p = (MPI_Fint *) &v;
+        if (p[pos] != *value) {
+            printf("Checking MPI-2 C attribute value backend (truncate), got value=%x; expected %x\n",
+                   (int)(uintptr_t) xlate.c_ptr, p[pos]);
+            exit(1);
+        }
+    }
+}
+
+
+static void c_check_mpi2_backend(MPI_Fint *key, MPI_Aint *value)
+{
+    int k = (int) *key;
+    int *v;
+
+    if (k == c_keyval1 || k == c_comm_keyval1 || k == c_type_keyval1 ||
+        k == c_win_keyval1) {
+        v = &c_value1;
+    } else if (k == c_keyval2 || k == c_comm_keyval2 || k == c_type_keyval2 ||
+        k == c_win_keyval2) {
+        v = &c_value2;
+    } else {
+        v = &c_value3;
+    }
+
+    if (((int*) *value) != v) {
+        printf("Checking MPI-2 C attribute value backend, got value=%x; expected %x\n",
+               (int) *value, (int)(uintptr_t) v);
+        exit(1);
+    }
+}
diff --git a/ompi/test/general/attr_interlang_source.F90 b/ompi/test/general/attr_interlang_source.F90
new file mode 100644
index 00000000000..64e663269a6
--- /dev/null
+++ b/ompi/test/general/attr_interlang_source.F90
@@ -0,0 +1,1319 @@
+! -*- fortran -*-
+!
+! Copyright (c) 2012      Cisco Systems, Inc.  All rights reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+! $COPYRIGHT$
+!
+! Additional copyrights may follow
+!
+! $HEADER$
+!
+! Fortran driver template for the C<->Fortran attribute interlanguage
+! test.  Adapted from the open-mpi/ompi-tests simple/attr test
+! (attr_fortran_source.F90).  The placeholders FORTRAN_SUB_LINE1,
+! FORTRAN_SUB_LINE2, and FORTRAN_*_TYPE are substituted by the Makefile
+! to generate the mpif.h, "use mpi", and "use mpi_f08" variants.
+!
+
+!     This test checks the 9 possible cases of MPI attributes reads and
+!     writes.  See ompi/attribute/attribute.c for details, but
+!     here's a summary:
+!
+!     1. C writes, C reads
+!     2. C writes, Fortran MPI-1 reads
+!     3. C writes, Fortran MPI-2 reads
+!     4. Fortran MPI-1 writes, C reads
+!     5. Fortran MPI-1 writes, Fortran MPI-1 reads
+!     6. Fortran MPI-1 writes, Fortran MPI-2 reads
+!     7. Fortran MPI-2 writes, C reads
+!     8. Fortran MPI-2 writes, Fortran MPI-1 reads
+!     9. Fortran MPI-2 writes, Fortran MPI-2 reads
+!
+!     MPI has different rules for each case.  We test them all here.
+!     Ugh.
+!
+      program main
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer ierr
+      integer bogus
+      integer(KIND=MPI_ADDRESS_KIND) :: aint
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+      call MPI_INIT(ierr)
+
+      aint = 1
+      call MPI_WIN_CREATE(bogus, aint, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &
+          win, ierr)
+
+      call C_CREATE_KEYVAL(keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3)
+      call F_MPI1_CREATE_KEYVAL()
+      call F_MPI2_CREATE_KEYVAL()
+
+      call C_WRITE(keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, win)
+      call F_MPI1_WRITE()
+      call F_MPI2_WRITE()
+
+      call C_READ(keyval_c1, keyval_c2, &
+          keyval_comm_c1, keyval_comm_c2, &
+          keyval_type_c1, keyval_type_c2, &
+          keyval_win_c1, keyval_win_c2, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win)
+      call F_MPI1_READ()
+      call F_MPI2_READ()
+
+      call MPI_WIN_FREE(win, ierr)
+
+      print *, "Calling MPI_Finalize"
+      call MPI_FINALIZE(ierr)
+      print *, "Test complete"
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+! MPI-1
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI1_CREATE_KEYVAL()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer ierr
+      external MPI1_COPY_FN, MPI1_DELETE_FN
+
+      integer f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+      integer(kind=MPI_ADDRESS_KIND) :: f_mpi21_extra, f_mpi22_extra, f_mpi23_extra
+
+      common /extras/ f_mpi21_extra, f_mpi22_extra, f_mpi23_extra, &
+           f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+      print *, "Creating MPI-1 Fortran keyval 1"
+
+      call MPI_KEYVAL_CREATE(MPI1_COPY_FN, MPI1_DELETE_FN, &
+          keyval_f_mpi11, f_mpi11_extra, ierr)
+      print *, "Fortran MPI-1: created keyval ", keyval_f_mpi11
+
+      print *, "Creating MPI-1 Fortran keyval 2"
+
+      call MPI_KEYVAL_CREATE(MPI1_COPY_FN, MPI1_DELETE_FN, &
+          keyval_f_mpi12, f_mpi12_extra, ierr)
+      print *, "Fortran MPI-1: created keyval ", keyval_f_mpi12
+
+      print *, "Creating MPI-1 Fortran keyval 3"
+
+      call MPI_KEYVAL_CREATE(MPI_NULL_COPY_FN, MPI_NULL_DELETE_FN, &
+          keyval_f_mpi13, f_mpi13_extra, ierr)
+      print *, "Fortran MPI-1: created keyval ", keyval_f_mpi13
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI1_WRITE()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer ierr, key
+      integer val_write, val_read
+      FORTRAN_COMM_TYPE comm2
+      logical flag
+      integer tmp
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+! Write attribute 1
+
+      print *, "Writing MPI-1 Fortran attribute 1"
+      val_write = FORTRAN_MPI1_VALUE1
+      tmp = val_write
+      call MPI_ATTR_PUT(MPI_COMM_SELF, keyval_f_mpi11, val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-1 Fortran write sanity check"
+      val_write = val_write + 1
+      call F_MPI1_READ_CHECK(keyval_f_mpi11, tmp, 0)
+
+! Dup the comm; it should follow
+
+      print *, "MPI-1 Fortran duping comm"
+      call MPI_COMM_DUP(MPI_COMM_SELF, comm2, ierr);
+
+! Is it there?
+
+      val_read = 0
+      call MPI_ATTR_GET(comm2, keyval_f_mpi11, val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading MPI-1 Fortran attribute got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp * 2) then
+         print *, "ERROR: reading MPI-1 Fortran attribute got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp * 2
+         stop
+      endif
+
+! Ok
+
+      call MPI_COMM_FREE(comm2, ierr)
+
+! Write attribute 2
+
+      print *, "Writing MPI-1 Fortran attribute 2"
+      val_write = FORTRAN_MPI1_VALUE2
+      tmp = val_write
+      call MPI_ATTR_PUT(MPI_COMM_SELF, keyval_f_mpi12, val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-1 Fortran write sanity check"
+      val_write = val_write + 1
+      call F_MPI1_READ_CHECK(keyval_f_mpi12, tmp, 0)
+
+! Dup the comm; it should follow
+
+      print *, "MPI-1 Fortran duping comm"
+      call MPI_COMM_DUP(MPI_COMM_SELF, comm2, ierr);
+
+! Is it there?
+
+      print *, "MPI-1 Fortran reading from duped comm"
+      val_read = 0
+      call MPI_ATTR_GET(comm2, keyval_f_mpi12, val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading MPI-1 Fortran attribute got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp * 2) then
+         print *, "ERROR: reading MPI-1 Fortran attribute got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp * 2
+         stop
+      endif
+
+! Ok
+
+      call MPI_COMM_FREE(comm2, ierr)
+
+! Write attribute 2
+
+      print *, "Writing MPI-1 Fortran attribute 3"
+      val_write = FORTRAN_MPI1_VALUE3
+      tmp = val_write
+      call MPI_ATTR_PUT(MPI_COMM_SELF, keyval_f_mpi13, val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-1 Fortran write sanity check"
+      val_write = val_write + 1
+      call F_MPI1_READ_CHECK(keyval_f_mpi13, tmp, 0)
+
+! Dup the comm; it should NOT follow (since it was created with a
+! NULL_COPY callback)
+
+      print *, "MPI-1 Fortran duping comm"
+      call MPI_COMM_DUP(MPI_COMM_SELF, comm2, ierr);
+
+! Is it there?
+
+      print *, "MPI-1 Fortran reading from duped comm == foo"
+      val_read = 0
+      call MPI_ATTR_GET(comm2, keyval_f_mpi13, val_read, flag, ierr)
+      if (.true. .eqv.  flag) then
+         print *, "ERROR: reading MPI-1 Fortran attribute got flag=.true."
+         stop
+      endif
+
+! Ok
+
+      call MPI_COMM_FREE(comm2, ierr)
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI1_READ()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+      print *, "Case 2: C writes, Fortran MPI-1 reads"
+      call F_MPI1_READ_CHECK(keyval_c1, C_VALUE1, 1)
+      call F_MPI1_READ_CHECK(keyval_c2, C_VALUE2, 1)
+      call F_MPI1_READ_CHECK(keyval_c3, C_VALUE3, 1)
+      call F_MPI1_READ_CHECK(keyval_comm_c1, C_VALUE1, 1)
+      call F_MPI1_READ_CHECK(keyval_comm_c2, C_VALUE2, 1)
+      call F_MPI1_READ_CHECK(keyval_comm_c3, C_VALUE3, 1)
+
+      print *, "Case 5: Fortran MPI-1 writes, Fortran MPI-1 reads"
+      call F_MPI1_READ_CHECK(keyval_f_mpi11, FORTRAN_MPI1_VALUE1, 0)
+      call F_MPI1_READ_CHECK(keyval_f_mpi12, FORTRAN_MPI1_VALUE2, 0)
+      call F_MPI1_READ_CHECK(keyval_f_mpi13, FORTRAN_MPI1_VALUE3, 0)
+
+      print *, "Case 8: Fortran MPI-2 writes, Fortran MPI-1 reads"
+      call F_MPI1_READ_CHECK(keyval_comm_f_mpi21, &
+                            FORTRAN_MPI2_VALUE1, 0)
+      call F_MPI1_READ_CHECK(keyval_comm_f_mpi22, &
+                            FORTRAN_MPI2_VALUE2, 0)
+      call F_MPI1_READ_CHECK(keyval_comm_f_mpi23, &
+                            FORTRAN_MPI2_VALUE3, 0)
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI1_READ_CHECK(key, expected_value, check_c)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      integer key, expected_value, check_c
+      integer ierr
+      integer val_read
+      logical flag
+
+      val_read = 0
+      call MPI_ATTR_GET(MPI_COMM_SELF, key, val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute got flag=.false."
+         stop
+      endif
+      if (check_c == 1) then
+         call C_CHECK_MPI1(key, val_read)
+      else
+         if (val_read .ne. expected_value) then
+            print *, "ERROR: reading attribute got value=", &
+                val_read
+            print *, "ERROR: when expecting value=", expected_value
+            stop
+         endif
+      endif
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE MPI1_COPY_FN(oldcomm, &
+                             keyval, &
+                             extra_state, &
+                             in, &
+                             out, &
+                             flag, &
+                             ierr)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      FORTRAN_COMM_TYPE oldcomm
+      integer keyval
+      integer extra_state
+      integer in
+      integer out
+      logical flag
+      integer ierr
+
+      print *, "In MPI1_COPY_FN"
+      flag = .TRUE.
+      out = in * 2
+      extra_state = extra_state + 1
+      ierr = MPI_SUCCESS
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE MPI1_DELETE_FN(oldcomm, &
+                               keyval, &
+                               in, &
+                               extra_state, &
+                               ierr)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      FORTRAN_COMM_TYPE oldcomm
+      integer keyval
+      integer in
+      integer extra_state
+      integer ierr
+
+      print *, "In MPI1_DELETE_FN"
+      extra_state = extra_state + 1
+      ierr = MPI_SUCCESS
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+! MPI-2
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_CREATE_KEYVAL()
+      implicit none
+
+      call F_MPI2_CREATE_KEYVAL_COMM()
+      call F_MPI2_CREATE_KEYVAL_TYPE()
+      call F_MPI2_CREATE_KEYVAL_WIN()
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_CREATE_KEYVAL_COMM()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+      integer ierr
+      external MPI2_COPY_FN, MPI2_DELETE_FN
+
+      integer f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+      integer(kind=MPI_ADDRESS_KIND) :: f_mpi21_extra, f_mpi22_extra, f_mpi23_extra
+
+      common /extras/ f_mpi21_extra, f_mpi22_extra, f_mpi23_extra, &
+           f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+      print *, "Creating MPI-2 Fortran keyval comm 1"
+      call MPI_COMM_CREATE_KEYVAL(MPI2_COPY_FN, MPI2_DELETE_FN, &
+          keyval_comm_f_mpi21, f_mpi21_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_comm_f_mpi21
+
+      print *, "Creating MPI-1 Fortran keyval comm 2"
+      call MPI_COMM_CREATE_KEYVAL(MPI2_COPY_FN, MPI2_DELETE_FN, &
+          keyval_comm_f_mpi22, f_mpi22_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_comm_f_mpi22
+
+      print *, "Creating MPI-1 Fortran keyval comm 3"
+      call MPI_COMM_CREATE_KEYVAL(MPI_COMM_NULL_COPY_FN, MPI_COMM_NULL_DELETE_FN, &
+          keyval_comm_f_mpi23, f_mpi23_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_comm_f_mpi23
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_CREATE_KEYVAL_TYPE()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+      integer ierr
+      external MPI2_COPY_FN, MPI2_DELETE_FN
+
+      integer f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+      integer(kind=MPI_ADDRESS_KIND) :: f_mpi21_extra, f_mpi22_extra, f_mpi23_extra
+
+      common /extras/ f_mpi21_extra, f_mpi22_extra, f_mpi23_extra, &
+           f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+      call MPI_TYPE_CREATE_KEYVAL(MPI2_COPY_FN, MPI2_DELETE_FN, &
+          keyval_type_f_mpi21, f_mpi21_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_type_f_mpi21
+
+      print *, "Creating MPI-1 Fortran keyval type 2"
+      call MPI_TYPE_CREATE_KEYVAL(MPI2_COPY_FN, MPI2_DELETE_FN, &
+          keyval_type_f_mpi22, f_mpi22_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_type_f_mpi22
+
+      print *, "Creating MPI-1 Fortran keyval type 3"
+      call MPI_TYPE_CREATE_KEYVAL(MPI_TYPE_NULL_COPY_FN, MPI_TYPE_NULL_DELETE_FN, &
+          keyval_type_f_mpi23, f_mpi23_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_type_f_mpi23
+
+      return
+      end
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_CREATE_KEYVAL_WIN()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+      integer ierr
+      external MPI2_COPY_FN, MPI2_DELETE_FN
+
+      integer f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+      integer(kind=MPI_ADDRESS_KIND) :: f_mpi21_extra, f_mpi22_extra, f_mpi23_extra
+
+      common /extras/ f_mpi21_extra, f_mpi22_extra, f_mpi23_extra, &
+           f_mpi11_extra, f_mpi12_extra, f_mpi13_extra
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+      print *, "Creating MPI-2 Fortran keyval win 1"
+      call MPI_WIN_CREATE_KEYVAL(MPI2_COPY_FN, MPI2_DELETE_FN, &
+          keyval_win_f_mpi21, f_mpi21_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_win_f_mpi21
+
+      print *, "Creating MPI-1 Fortran keyval win 2"
+      call MPI_WIN_CREATE_KEYVAL(MPI2_COPY_FN, MPI2_DELETE_FN, &
+          keyval_win_f_mpi22, f_mpi22_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_win_f_mpi22
+
+      print *, "Creating MPI-1 Fortran keyval win 3"
+      call MPI_WIN_CREATE_KEYVAL(MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN, &
+          keyval_win_f_mpi23, f_mpi23_extra, ierr)
+      print *, "Fortran MPI-2: created keyval ", keyval_win_f_mpi23
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_WRITE()
+      implicit none
+
+      call F_MPI2_WRITE_COMM()
+      call F_MPI2_WRITE_TYPE()
+      call F_MPI2_WRITE_WIN()
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_WRITE_COMM()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer ierr, key
+      integer(kind=MPI_ADDRESS_KIND) :: val_write, val_read, tmp
+      FORTRAN_COMM_TYPE comm2
+      logical flag
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+! Write attribute 1
+
+      print *, "Writing MPI-2 Fortran comm attribute 1"
+      val_write = FORTRAN_MPI2_VALUE1
+      tmp = val_write
+      call MPI_COMM_SET_ATTR(MPI_COMM_SELF, keyval_comm_f_mpi21, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran comm write sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_COMM_GET_ATTR(MPI_COMM_SELF, keyval_comm_f_mpi21, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Dup the comm; it should follow
+
+      print *, "MPI-2 Fortran duping comm"
+      call MPI_COMM_DUP(MPI_COMM_SELF, comm2, ierr);
+
+! Is it there?
+
+      print *, "MPI-2 Fortran reading from duped comm"
+      val_read = 0
+      call MPI_COMM_GET_ATTR(comm2, keyval_comm_f_mpi21, val_read, &
+          flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp * 2) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp * 2
+         stop
+      endif
+
+! Ok
+
+      call MPI_COMM_FREE(comm2, ierr)
+
+! Write attribute 2
+
+      print *, "Writing MPI-2 Fortran comm attribute 2"
+      val_write = FORTRAN_MPI2_VALUE2
+      tmp = val_write
+      call MPI_COMM_SET_ATTR(MPI_COMM_SELF, keyval_comm_f_mpi22, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran write comm sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_COMM_GET_ATTR(MPI_COMM_SELF, keyval_comm_f_mpi22, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Dup the comm; it should follow
+
+      print *, "MPI-2 Fortran duping comm"
+      call MPI_COMM_DUP(MPI_COMM_SELF, comm2, ierr);
+
+! Is it there?
+
+      print *, "MPI-2 Fortran reading from duped comm"
+      val_read = 0
+      call MPI_COMM_GET_ATTR(comm2, keyval_comm_f_mpi22, val_read, &
+          flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp * 2) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp * 2
+         stop
+      endif
+
+! Ok
+
+      call MPI_COMM_FREE(comm2, ierr)
+
+! Write attribute 3
+
+      print *, "Writing MPI-2 Fortran comm attribute 3"
+      val_write = FORTRAN_MPI2_VALUE3
+      tmp = val_write
+      call MPI_COMM_SET_ATTR(MPI_COMM_SELF, keyval_comm_f_mpi23, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran write comm sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_COMM_GET_ATTR(MPI_COMM_SELF, keyval_comm_f_mpi23, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Dup the comm; it should NOT follow (it was created with a NULL_COPY
+! callback)
+
+      print *, "MPI-2 Fortran duping comm"
+      call MPI_COMM_DUP(MPI_COMM_SELF, comm2, ierr);
+
+! Is it there?
+
+      print *, "MPI-2 Fortran reading from duped comm"
+      val_read = 0
+      call MPI_COMM_GET_ATTR(comm2, keyval_comm_f_mpi23, val_read, &
+          flag, ierr)
+      if (.true. .eqv.  flag) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got flag=.true."
+         stop
+      endif
+
+! Ok
+
+      call MPI_COMM_FREE(comm2, ierr)
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_WRITE_TYPE()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer ierr, key
+      integer(kind=MPI_ADDRESS_KIND) :: val_write, val_read, tmp
+      FORTRAN_DATATYPE_TYPE type2
+      logical flag
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+! Write attribute 1
+
+      print *, "Writing MPI-2 Fortran type attribute 1"
+      val_write = FORTRAN_MPI2_VALUE1
+      tmp = val_write
+      call MPI_TYPE_SET_ATTR(MPI_INTEGER, keyval_type_f_mpi21, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran type write sanity check"
+      val_read = 0
+      call MPI_TYPE_GET_ATTR(MPI_INTEGER, keyval_type_f_mpi21, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Dup the type; it should follow
+
+      print *, "MPI-2 Fortran duping type"
+      call MPI_TYPE_DUP(MPI_INTEGER, type2, ierr);
+
+! Is it there?
+
+      print *, "MPI-2 Fortran reading from duped type"
+      val_read = 0
+      call MPI_TYPE_GET_ATTR(type2, keyval_type_f_mpi21, val_read, &
+          flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp * 2) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp * 2
+         stop
+      endif
+
+! Ok
+
+      call MPI_TYPE_FREE(type2, ierr)
+
+! Write attribute 2
+
+      print *, "Writing MPI-2 Fortran type attribute 2"
+      val_write = FORTRAN_MPI2_VALUE2
+      tmp = val_write
+      call MPI_TYPE_SET_ATTR(MPI_INTEGER, keyval_type_f_mpi22, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran type write sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_TYPE_GET_ATTR(MPI_INTEGER, keyval_type_f_mpi22, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Dup the type; it should follow
+
+      print *, "MPI-2 Fortran duping type"
+      call MPI_TYPE_DUP(MPI_INTEGER, type2, ierr);
+
+! Is it there?
+
+      print *, "MPI-2 Fortran reading from duped type"
+      val_read = 0
+      call MPI_TYPE_GET_ATTR(type2, keyval_type_f_mpi22, val_read, &
+          flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp * 2) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp * 2
+         stop
+      endif
+
+! Ok
+
+      call MPI_TYPE_FREE(type2, ierr)
+
+! Write attribute 3
+
+      print *, "Writing MPI-2 Fortran type attribute 3"
+      val_write = FORTRAN_MPI2_VALUE3
+      tmp = val_write
+      call MPI_TYPE_SET_ATTR(MPI_INTEGER, keyval_type_f_mpi23, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran type write sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_TYPE_GET_ATTR(MPI_INTEGER, keyval_type_f_mpi23, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Dup the type; it should NUL follow (it was created with a NULL_COPY
+! callback)
+
+      print *, "MPI-2 Fortran duping type"
+      call MPI_TYPE_DUP(MPI_INTEGER, type2, ierr);
+
+! Is it there?
+
+      print *, "MPI-2 Fortran reading from duped type"
+      val_read = 0
+      call MPI_TYPE_GET_ATTR(type2, keyval_type_f_mpi23, val_read, &
+          flag, ierr)
+      if (.true. .eqv.  flag) then
+         print *, "ERROR: reading MPI-2 Fortran attribute got flag=.true."
+         stop
+      endif
+
+! Ok
+
+      call MPI_TYPE_FREE(type2, ierr)
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_WRITE_WIN()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer ierr, key
+      integer(kind=MPI_ADDRESS_KIND) :: val_write, val_read, tmp
+      logical flag
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+! Write attribute 1
+
+      print *, "Writing MPI-2 Fortran win attribute 1"
+      val_write = FORTRAN_MPI2_VALUE1
+      tmp = val_write
+      print *, "Writing to keyval: ", keyval_win_f_mpi21
+      call MPI_WIN_SET_ATTR(win, keyval_win_f_mpi21, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran win write sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_WIN_GET_ATTR(win, keyval_win_f_mpi21, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Write attribute 2
+
+      print *, "Writing MPI-2 Fortran win attribute 2"
+      val_write = FORTRAN_MPI2_VALUE2
+      tmp = val_write
+      print *, "Writing to keyval: ", keyval_win_f_mpi22
+      call MPI_WIN_SET_ATTR(win, keyval_win_f_mpi22, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran win write sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_WIN_GET_ATTR(win, keyval_win_f_mpi22, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+! Write attribute 3
+
+      print *, "Writing MPI-2 Fortran win attribute 3"
+      val_write = FORTRAN_MPI2_VALUE3
+      tmp = val_write
+      print *, "Writing to keyval: ", keyval_win_f_mpi23
+      call MPI_WIN_SET_ATTR(win, keyval_win_f_mpi23, &
+          val_write, ierr)
+
+! Sanity check (unity)
+
+      print *, "MPI-2 Fortran win write sanity check"
+      val_write = val_write + 1
+      val_read = 0
+      call MPI_WIN_GET_ATTR(win, keyval_win_f_mpi23, &
+          val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute 1 got flag=.false."
+         stop
+      endif
+      if (val_read .ne. tmp) then
+         print *, "ERROR: reading attribute 1 got value=", &
+                  val_read
+         print *, "ERROR: when expecting value=", tmp
+         stop
+      endif
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_READ()
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      include "values-f.h"
+
+      integer keyval_c1, keyval_c2, keyval_c3
+      integer keyval_comm_c1, keyval_comm_c2, keyval_comm_c3
+      integer keyval_type_c1, keyval_type_c2, keyval_type_c3
+      integer keyval_win_c1, keyval_win_c2, keyval_win_c3
+      integer keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13
+      integer keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23
+      integer keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23
+      integer keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23
+      FORTRAN_WIN_TYPE win
+
+      common /keyvals/ keyval_c1, keyval_c2, keyval_c3, &
+          keyval_comm_c1, keyval_comm_c2, keyval_comm_c3, &
+          keyval_type_c1, keyval_type_c2, keyval_type_c3, &
+          keyval_win_c1, keyval_win_c2, keyval_win_c3, &
+          keyval_f_mpi11, keyval_f_mpi12, keyval_f_mpi13, &
+          keyval_comm_f_mpi21, keyval_comm_f_mpi22, keyval_comm_f_mpi23, &
+          keyval_type_f_mpi21, keyval_type_f_mpi22, keyval_type_f_mpi23, &
+          keyval_win_f_mpi21, keyval_win_f_mpi22, keyval_win_f_mpi23, &
+          win
+
+      integer(kind=MPI_ADDRESS_KIND) val1, val2, val3
+
+!     Note that C's 6 keyvals wrote a pointer to a C int, which may not
+!     be the same size as an integer(kind=MPI_ADDRESS_KIND).
+
+      print *, "Case 3: C writes, Fortran MPI-2 reads"
+      val1 = C_VALUE1
+      val2 = C_VALUE2
+      val3 = C_VALUE3
+      call F_MPI2_READ_COMM_CHECK(keyval_c1, val1, 1)
+      call F_MPI2_READ_COMM_CHECK(keyval_c2, val2, 1)
+      call F_MPI2_READ_COMM_CHECK(keyval_c3, val3, 1)
+      call F_MPI2_READ_COMM_CHECK(keyval_comm_c1, val1, 1)
+      call F_MPI2_READ_COMM_CHECK(keyval_comm_c2, val2, 1)
+      call F_MPI2_READ_COMM_CHECK(keyval_comm_c3, val3, 1)
+      call F_MPI2_READ_TYPE_CHECK(keyval_type_c1, val1, 1)
+      call F_MPI2_READ_TYPE_CHECK(keyval_type_c2, val2, 1)
+      call F_MPI2_READ_TYPE_CHECK(keyval_type_c3, val3, 1)
+      call F_MPI2_READ_WIN_CHECK(win, keyval_win_c1, val1, 1)
+      call F_MPI2_READ_WIN_CHECK(win, keyval_win_c2, val2, 1)
+      call F_MPI2_READ_WIN_CHECK(win, keyval_win_c3, val3, 1)
+
+      print *, "Case 6: Fortran MPI-1 writes, Fortran MPI-2 reads"
+      val1 = FORTRAN_MPI1_VALUE1
+      val2 = FORTRAN_MPI1_VALUE2
+      val3 = FORTRAN_MPI1_VALUE3
+      call F_MPI2_READ_COMM_CHECK(keyval_f_mpi11, val1, 0)
+      call F_MPI2_READ_COMM_CHECK(keyval_f_mpi12, val2, 0)
+      call F_MPI2_READ_COMM_CHECK(keyval_f_mpi13, val3, 0)
+
+      print *, "Case 9: Fortran MPI-2 writes, Fortran MPI-2 reads"
+      val1 = FORTRAN_MPI2_VALUE1
+      val2 = FORTRAN_MPI2_VALUE2
+      val3 = FORTRAN_MPI2_VALUE3
+      call F_MPI2_READ_COMM_CHECK(keyval_comm_f_mpi21, val1, 0)
+      call F_MPI2_READ_COMM_CHECK(keyval_comm_f_mpi22, val2, 0)
+      call F_MPI2_READ_COMM_CHECK(keyval_comm_f_mpi23, val3, 0)
+      call F_MPI2_READ_TYPE_CHECK(keyval_type_f_mpi21, val1, 0)
+      call F_MPI2_READ_TYPE_CHECK(keyval_type_f_mpi22, val2, 0)
+      call F_MPI2_READ_TYPE_CHECK(keyval_type_f_mpi23, val3, 0)
+      call F_MPI2_READ_WIN_CHECK(win, keyval_win_f_mpi21, val1, 0)
+      call F_MPI2_READ_WIN_CHECK(win, keyval_win_f_mpi22, val2, 0)
+      call F_MPI2_READ_WIN_CHECK(win, keyval_win_f_mpi23, val3, 0)
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_READ_COMM_CHECK(key, expected_value, c_check)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      integer key
+      integer ierr
+      logical flag
+      integer(kind=MPI_ADDRESS_KIND) val_read, expected_value
+      integer c_check
+
+      val_read = 0
+      call MPI_COMM_GET_ATTR(MPI_COMM_SELF, key, val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute got flag=.false."
+         stop
+      endif
+      if (c_check == 1) then
+         call C_CHECK_MPI2(key, val_read)
+      else
+         if (val_read .ne. expected_value) then
+            print *, "ERROR: reading attribute got value=", &
+                val_read
+            print *, "ERROR: when expecting value=", expected_value
+            stop
+         endif
+      endif
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_READ_TYPE_CHECK(key, expected_value, c_check)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      integer key
+      integer ierr
+      logical flag
+      integer(kind=MPI_ADDRESS_KIND) val_read, expected_value
+      integer c_check
+
+      val_read = 0
+      call MPI_TYPE_GET_ATTR(MPI_INTEGER, key, val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute got flag=.false."
+         stop
+      endif
+      if (c_check == 1) then
+         call C_CHECK_MPI2(key, val_read)
+      else
+         if (val_read .ne. expected_value) then
+            print *, "ERROR: reading attribute got value=", &
+                val_read
+            print *, "ERROR: when expecting value=", expected_value
+            stop
+         endif
+      endif
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE F_MPI2_READ_WIN_CHECK(win, key, expected_value, &
+          c_check)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      FORTRAN_WIN_TYPE win
+      integer key
+      integer ierr
+      logical flag
+      integer(kind=MPI_ADDRESS_KIND) val_read, expected_value
+      integer c_check
+
+      val_read = 0
+      call MPI_WIN_GET_ATTR(win, key, val_read, flag, ierr)
+      if (.false. .eqv.  flag) then
+         print *, "ERROR: reading attribute got flag=.false."
+         stop
+      endif
+      if (c_check == 1) then
+         call C_CHECK_MPI2(key, val_read)
+      else
+         if (val_read .ne. expected_value) then
+            print *, "ERROR: reading attribute got value=", &
+                val_read
+            print *, "ERROR: when expecting value=", expected_value
+            stop
+         endif
+      endif
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE MPI2_COPY_FN(oldcomm, &
+                             keyval, &
+                             extra_state, &
+                             in, &
+                             out, &
+                             flag, &
+                             ierr)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      FORTRAN_COMM_TYPE oldcomm
+      integer keyval
+      integer(kind=MPI_ADDRESS_KIND) extra_state, in, out
+      logical flag
+      integer ierr
+
+      print *, "In MPI2_COPY_FN"
+      flag = .TRUE.
+      out = in * 2
+      extra_state = extra_state + 1
+      ierr = MPI_SUCCESS
+
+      return
+      end
+
+!CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
+
+      SUBROUTINE MPI2_DELETE_FN(oldcomm, &
+                               keyval, &
+                               in, &
+                               extra_state, &
+                               ierr)
+      FORTRAN_SUB_LINE1
+      FORTRAN_SUB_LINE2
+      FORTRAN_COMM_TYPE oldcomm
+      integer keyval
+      integer(kind=MPI_ADDRESS_KIND) in, extra_state
+      integer ierr
+
+      print *, "In MPI2_DELETE_FN"
+      extra_state = extra_state + 1
+      ierr = MPI_SUCCESS
+
+      return
+      end
diff --git a/ompi/test/general/attribute.c b/ompi/test/general/attribute.c
new file mode 100644
index 00000000000..dd7c5d702a4
--- /dev/null
+++ b/ompi/test/general/attribute.c
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/attribute engine (attribute.c,
+ * attribute_predefined.c).  Exercised through the public MPI keyval /
+ * attribute API on communicators, datatypes, and windows after a full
+ * singleton MPI_Init, including copy/delete callbacks (driven via
+ * dup) and the predefined attributes (MPI_TAG_UB, etc.).
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include "support.h"
+
+#include "mpi.h"
+
+/* callback bookkeeping */
+static int comm_copy_calls = 0;
+static int comm_delete_calls = 0;
+
+static int comm_copy_fn(MPI_Comm comm, int keyval, void *extra,
+                        void *attr_in, void *attr_out, int *flag)
+{
+    (void) comm; (void) keyval; (void) extra;
+    ++comm_copy_calls;
+    *(void **) attr_out = attr_in; /* propagate to the duplicate */
+    *flag = 1;
+    return MPI_SUCCESS;
+}
+
+static int comm_delete_fn(MPI_Comm comm, int keyval, void *attr, void *extra)
+{
+    (void) comm; (void) keyval; (void) attr; (void) extra;
+    ++comm_delete_calls;
+    return MPI_SUCCESS;
+}
+
+static void test_comm_attr(void);
+static void test_comm_predefined(void);
+static void test_type_attr(void);
+static void test_win_attr(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi attribute");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_comm_attr();
+    test_comm_predefined();
+    test_type_attr();
+    test_win_attr();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_comm_attr(void)
+{
+    int keyval = MPI_KEYVAL_INVALID;
+    int rc = MPI_Comm_create_keyval(comm_copy_fn, comm_delete_fn, &keyval, NULL);
+    test_verify("Comm_create_keyval succeeds", MPI_SUCCESS == rc);
+    test_verify("keyval is valid", MPI_KEYVAL_INVALID != keyval);
+
+    static int value = 1234;
+    MPI_Comm base = MPI_COMM_NULL;
+    MPI_Comm_dup(MPI_COMM_WORLD, &base);
+
+    rc = MPI_Comm_set_attr(base, keyval, &value);
+    test_verify("Comm_set_attr succeeds", MPI_SUCCESS == rc);
+
+    void *got = NULL;
+    int flag = 0;
+    MPI_Comm_get_attr(base, keyval, &got, &flag);
+    test_verify("get_attr finds the attribute", 1 == flag);
+    test_verify("attribute value round-trips", got == &value);
+
+    /* dup must invoke the copy callback */
+    comm_copy_calls = 0;
+    MPI_Comm dup = MPI_COMM_NULL;
+    MPI_Comm_dup(base, &dup);
+    test_verify("copy callback fired during dup", comm_copy_calls >= 1);
+    flag = 0; got = NULL;
+    MPI_Comm_get_attr(dup, keyval, &got, &flag);
+    test_verify("attribute copied to the duplicate", 1 == flag && got == &value);
+
+    /* delete must invoke the delete callback */
+    comm_delete_calls = 0;
+    rc = MPI_Comm_delete_attr(base, keyval);
+    test_verify("Comm_delete_attr succeeds", MPI_SUCCESS == rc);
+    test_verify("delete callback fired", 1 == comm_delete_calls);
+    flag = 1;
+    MPI_Comm_get_attr(base, keyval, &got, &flag);
+    test_verify("attribute gone after delete", 0 == flag);
+
+    /* freeing a comm with a live attribute also fires delete */
+    comm_delete_calls = 0;
+    MPI_Comm_free(&dup);
+    test_verify("delete callback fired on comm free", comm_delete_calls >= 1);
+
+    MPI_Comm_free(&base);
+    rc = MPI_Comm_free_keyval(&keyval);
+    test_verify("Comm_free_keyval succeeds", MPI_SUCCESS == rc);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_comm_predefined(void)
+{
+    int *valp = NULL;
+    int flag = 0;
+
+    MPI_Comm_get_attr(MPI_COMM_WORLD, MPI_TAG_UB, &valp, &flag);
+    test_verify("MPI_TAG_UB is present", 1 == flag);
+    test_verify("MPI_TAG_UB is at least 32767 (MPI minimum)",
+                NULL != valp && *valp >= 32767);
+
+    flag = 0;
+    MPI_Comm_get_attr(MPI_COMM_WORLD, MPI_WTIME_IS_GLOBAL, &valp, &flag);
+    test_verify("MPI_WTIME_IS_GLOBAL is present", 1 == flag);
+
+    flag = 0;
+    MPI_Comm_get_attr(MPI_COMM_WORLD, MPI_LASTUSEDCODE, &valp, &flag);
+    test_verify("MPI_LASTUSEDCODE is present", 1 == flag);
+
+    /* MPI_HOST and MPI_IO are required predefined attributes */
+    flag = 0;
+    MPI_Comm_get_attr(MPI_COMM_WORLD, MPI_IO, &valp, &flag);
+    test_verify("MPI_IO is present", 1 == flag);
+}
+
+/* ------------------------------------------------------------------ */
+
+static int type_copy_calls = 0;
+
+static int type_copy_fn(MPI_Datatype t, int keyval, void *extra,
+                        void *attr_in, void *attr_out, int *flag)
+{
+    (void) t; (void) keyval; (void) extra;
+    ++type_copy_calls;
+    *(void **) attr_out = attr_in;
+    *flag = 1;
+    return MPI_SUCCESS;
+}
+
+static void test_type_attr(void)
+{
+    int keyval = MPI_KEYVAL_INVALID;
+    int rc = MPI_Type_create_keyval(type_copy_fn, MPI_TYPE_NULL_DELETE_FN,
+                                    &keyval, NULL);
+    test_verify("Type_create_keyval succeeds", MPI_SUCCESS == rc);
+
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    MPI_Type_contiguous(2, MPI_INT, &t);
+    MPI_Type_commit(&t);
+
+    static int value = 99;
+    rc = MPI_Type_set_attr(t, keyval, &value);
+    test_verify("Type_set_attr succeeds", MPI_SUCCESS == rc);
+
+    void *got = NULL;
+    int flag = 0;
+    MPI_Type_get_attr(t, keyval, &got, &flag);
+    test_verify("Type_get_attr finds the attribute", 1 == flag && got == &value);
+
+    /* dup invokes the copy callback */
+    type_copy_calls = 0;
+    MPI_Datatype dup = MPI_DATATYPE_NULL;
+    MPI_Type_dup(t, &dup);
+    test_verify("type copy callback fired on dup", type_copy_calls >= 1);
+
+    rc = MPI_Type_delete_attr(t, keyval);
+    test_verify("Type_delete_attr succeeds", MPI_SUCCESS == rc);
+
+    MPI_Type_free(&dup);
+    MPI_Type_free(&t);
+    MPI_Type_free_keyval(&keyval);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_win_attr(void)
+{
+    MPI_Win win = MPI_WIN_NULL;
+    static int buffer[16];
+    int rc = MPI_Win_create(buffer, sizeof(buffer), sizeof(int),
+                            MPI_INFO_NULL, MPI_COMM_SELF, &win);
+    test_verify("Win_create succeeds", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS != rc || MPI_WIN_NULL == win) {
+        return;
+    }
+
+    int keyval = MPI_KEYVAL_INVALID;
+    rc = MPI_Win_create_keyval(MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN,
+                               &keyval, NULL);
+    test_verify("Win_create_keyval succeeds", MPI_SUCCESS == rc);
+
+    static int value = 7;
+    rc = MPI_Win_set_attr(win, keyval, &value);
+    test_verify("Win_set_attr succeeds", MPI_SUCCESS == rc);
+
+    void *got = NULL;
+    int flag = 0;
+    MPI_Win_get_attr(win, keyval, &got, &flag);
+    test_verify("Win_get_attr finds the attribute", 1 == flag && got == &value);
+
+    /* predefined window attribute MPI_WIN_BASE */
+    void *base = NULL;
+    flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_BASE, &base, &flag);
+    test_verify("MPI_WIN_BASE is present", 1 == flag);
+
+    rc = MPI_Win_delete_attr(win, keyval);
+    test_verify("Win_delete_attr succeeds", MPI_SUCCESS == rc);
+
+    MPI_Win_free_keyval(&keyval);
+    MPI_Win_free(&win);
+}
diff --git a/ompi/test/general/communicator.c b/ompi/test/general/communicator.c
new file mode 100644
index 00000000000..35cbbf98bc7
--- /dev/null
+++ b/ompi/test/general/communicator.c
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/communicator layer (comm.c, comm_init.c,
+ * comm_cid.c, ...).  Exercised through the public MPI communicator API
+ * after a full singleton MPI_Init.  All operations are valid for a
+ * size-1 (singleton) communicator, so no launcher is required.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <string.h>
+
+#include "support.h"
+
+#include "mpi.h"
+
+static void test_rank_size(void);
+static void test_dup(void);
+static void test_compare(void);
+static void test_name(void);
+static void test_group_roundtrip(void);
+static void test_split(void);
+static void test_split_type(void);
+static void test_info(void);
+static void test_attributes(void);
+static void test_misc(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi communicator");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_rank_size();
+    test_dup();
+    test_compare();
+    test_name();
+    test_group_roundtrip();
+    test_split();
+    test_split_type();
+    test_info();
+    test_attributes();
+    test_misc();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_rank_size(void)
+{
+    int rank = -1, size = -1;
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    test_verify("WORLD rank is 0", 0 == rank);
+    test_verify("WORLD size is 1", 1 == size);
+
+    int srank = -1, ssize = -1;
+    MPI_Comm_rank(MPI_COMM_SELF, &srank);
+    MPI_Comm_size(MPI_COMM_SELF, &ssize);
+    test_verify("SELF rank is 0", 0 == srank);
+    test_verify("SELF size is 1", 1 == ssize);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_dup(void)
+{
+    MPI_Comm dup = MPI_COMM_NULL;
+    int rc = MPI_Comm_dup(MPI_COMM_WORLD, &dup);
+    test_verify("Comm_dup succeeds", MPI_SUCCESS == rc);
+    test_verify("dup is not NULL", MPI_COMM_NULL != dup);
+
+    int size = -1;
+    MPI_Comm_size(dup, &size);
+    test_verify("dup has same size as WORLD", 1 == size);
+
+    MPI_Comm dwi = MPI_COMM_NULL;
+    rc = MPI_Comm_dup_with_info(MPI_COMM_WORLD, MPI_INFO_NULL, &dwi);
+    test_verify("Comm_dup_with_info succeeds", MPI_SUCCESS == rc);
+    test_verify("dup_with_info is not NULL", MPI_COMM_NULL != dwi);
+
+    MPI_Comm_free(&dup);
+    test_verify("free sets comm to NULL", MPI_COMM_NULL == dup);
+    MPI_Comm_free(&dwi);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_compare(void)
+{
+    int result = -1;
+    MPI_Comm_compare(MPI_COMM_WORLD, MPI_COMM_WORLD, &result);
+    test_verify("WORLD vs WORLD is MPI_IDENT", MPI_IDENT == result);
+
+    MPI_Comm dup = MPI_COMM_NULL;
+    MPI_Comm_dup(MPI_COMM_WORLD, &dup);
+    result = -1;
+    MPI_Comm_compare(MPI_COMM_WORLD, dup, &result);
+    test_verify("WORLD vs its dup is MPI_CONGRUENT", MPI_CONGRUENT == result);
+    MPI_Comm_free(&dup);
+
+    result = -1;
+    MPI_Comm_compare(MPI_COMM_WORLD, MPI_COMM_SELF, &result);
+    test_verify("WORLD vs SELF is not IDENT", MPI_IDENT != result);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_name(void)
+{
+    MPI_Comm dup = MPI_COMM_NULL;
+    MPI_Comm_dup(MPI_COMM_WORLD, &dup);
+
+    int rc = MPI_Comm_set_name(dup, "my_comm");
+    test_verify("Comm_set_name succeeds", MPI_SUCCESS == rc);
+
+    char name[MPI_MAX_OBJECT_NAME];
+    int len = -1;
+    memset(name, 0, sizeof(name));
+    rc = MPI_Comm_get_name(dup, name, &len);
+    test_verify("Comm_get_name succeeds", MPI_SUCCESS == rc);
+    test_verify("retrieved name matches", 0 == strcmp(name, "my_comm"));
+    test_verify("retrieved name length matches", (int) strlen("my_comm") == len);
+
+    MPI_Comm_free(&dup);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_group_roundtrip(void)
+{
+    MPI_Group grp = MPI_GROUP_NULL;
+    int rc = MPI_Comm_group(MPI_COMM_WORLD, &grp);
+    test_verify("Comm_group succeeds", MPI_SUCCESS == rc);
+
+    int gsize = -1, grank = -1;
+    MPI_Group_size(grp, &gsize);
+    MPI_Group_rank(grp, &grank);
+    test_verify("group size matches comm size", 1 == gsize);
+    test_verify("group rank matches comm rank", 0 == grank);
+
+    /* Build a communicator back from the full group. */
+    MPI_Comm newcomm = MPI_COMM_NULL;
+    rc = MPI_Comm_create(MPI_COMM_WORLD, grp, &newcomm);
+    test_verify("Comm_create from full group succeeds", MPI_SUCCESS == rc);
+    test_verify("created comm is not NULL", MPI_COMM_NULL != newcomm);
+    if (MPI_COMM_NULL != newcomm) {
+        int ns = -1;
+        MPI_Comm_size(newcomm, &ns);
+        test_verify("created comm has expected size", 1 == ns);
+        MPI_Comm_free(&newcomm);
+    }
+
+    MPI_Group_free(&grp);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_split(void)
+{
+    MPI_Comm sub = MPI_COMM_NULL;
+    int rc = MPI_Comm_split(MPI_COMM_WORLD, 0, 0, &sub);
+    test_verify("Comm_split succeeds", MPI_SUCCESS == rc);
+    test_verify("split produced a communicator", MPI_COMM_NULL != sub);
+    if (MPI_COMM_NULL != sub) {
+        int s = -1;
+        MPI_Comm_size(sub, &s);
+        test_verify("split comm has size 1 (singleton)", 1 == s);
+        MPI_Comm_free(&sub);
+    }
+
+    /* color = MPI_UNDEFINED must yield MPI_COMM_NULL */
+    MPI_Comm none = (MPI_Comm) 0xdeadbeef;
+    rc = MPI_Comm_split(MPI_COMM_WORLD, MPI_UNDEFINED, 0, &none);
+    test_verify("split with MPI_UNDEFINED color succeeds", MPI_SUCCESS == rc);
+    test_verify("split with MPI_UNDEFINED yields MPI_COMM_NULL", MPI_COMM_NULL == none);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_split_type(void)
+{
+    MPI_Comm shared = MPI_COMM_NULL;
+    int rc = MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, 0,
+                                 MPI_INFO_NULL, &shared);
+    test_verify("Comm_split_type(SHARED) succeeds", MPI_SUCCESS == rc);
+    if (MPI_COMM_NULL != shared) {
+        int ssize = -1;
+        MPI_Comm_size(shared, &ssize);
+        test_verify("shared-split comm has size 1 (singleton)", 1 == ssize);
+        MPI_Comm_free(&shared);
+    }
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_info(void)
+{
+    MPI_Comm dup = MPI_COMM_NULL;
+    MPI_Comm_dup(MPI_COMM_WORLD, &dup);
+
+    MPI_Info info = MPI_INFO_NULL;
+    MPI_Info_create(&info);
+    MPI_Info_set(info, "mpi_assert_no_any_tag", "true");
+
+    int rc = MPI_Comm_set_info(dup, info);
+    test_verify("Comm_set_info succeeds", MPI_SUCCESS == rc);
+
+    MPI_Info got = MPI_INFO_NULL;
+    rc = MPI_Comm_get_info(dup, &got);
+    test_verify("Comm_get_info succeeds", MPI_SUCCESS == rc);
+    test_verify("Comm_get_info returns an info object", MPI_INFO_NULL != got);
+    if (MPI_INFO_NULL != got) {
+        MPI_Info_free(&got);
+    }
+
+    MPI_Info_free(&info);
+    MPI_Comm_free(&dup);
+}
+
+/* ------------------------------------------------------------------ */
+
+static int delete_called = 0;
+
+static int copy_fn(MPI_Comm comm, int keyval, void *extra, void *attr_in,
+                   void *attr_out, int *flag)
+{
+    (void) comm; (void) keyval; (void) extra; (void) attr_in;
+    *(void **) attr_out = attr_in;
+    *flag = 1;
+    return MPI_SUCCESS;
+}
+
+static int delete_fn(MPI_Comm comm, int keyval, void *attr, void *extra)
+{
+    (void) comm; (void) keyval; (void) attr; (void) extra;
+    delete_called = 1;
+    return MPI_SUCCESS;
+}
+
+/* Light exercise of communicator-attached attributes (the attribute
+ * engine itself gets a dedicated test). */
+static void test_attributes(void)
+{
+    int keyval = MPI_KEYVAL_INVALID;
+    int rc = MPI_Comm_create_keyval(copy_fn, delete_fn, &keyval, NULL);
+    test_verify("Comm_create_keyval succeeds", MPI_SUCCESS == rc);
+
+    int val = 42;
+    rc = MPI_Comm_set_attr(MPI_COMM_SELF, keyval, &val);
+    test_verify("Comm_set_attr succeeds", MPI_SUCCESS == rc);
+
+    void *got = NULL;
+    int flag = 0;
+    rc = MPI_Comm_get_attr(MPI_COMM_SELF, keyval, &got, &flag);
+    test_verify("Comm_get_attr succeeds", MPI_SUCCESS == rc);
+    test_verify("attr flag set", 1 == flag);
+    test_verify("attr value round-trips", got == &val);
+
+    delete_called = 0;
+    rc = MPI_Comm_delete_attr(MPI_COMM_SELF, keyval);
+    test_verify("Comm_delete_attr succeeds", MPI_SUCCESS == rc);
+    test_verify("delete callback fired", 1 == delete_called);
+
+    rc = MPI_Comm_free_keyval(&keyval);
+    test_verify("Comm_free_keyval succeeds", MPI_SUCCESS == rc);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_misc(void)
+{
+    int flag = -1;
+    MPI_Comm_test_inter(MPI_COMM_WORLD, &flag);
+    test_verify("WORLD is not an inter-communicator", 0 == flag);
+
+    MPI_Comm parent = (MPI_Comm) 0xdeadbeef;
+    int rc = MPI_Comm_get_parent(&parent);
+    test_verify("Comm_get_parent succeeds", MPI_SUCCESS == rc);
+    test_verify("singleton has no parent (MPI_COMM_NULL)", MPI_COMM_NULL == parent);
+}
diff --git a/ompi/test/general/datatype.c b/ompi/test/general/datatype.c
new file mode 100644
index 00000000000..21c1cacdf43
--- /dev/null
+++ b/ompi/test/general/datatype.c
@@ -0,0 +1,670 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/datatype layer (ompi_datatype_create_*.c,
+ * ompi_datatype_module.c, ompi_datatype_args.c).  Exercised through the
+ * public MPI datatype constructor API after a full singleton MPI_Init;
+ * each MPI_Type_* call dispatches into the corresponding
+ * ompi_datatype_create_* function.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "support.h"
+
+#include "ompi/datatype/ompi_datatype.h"
+#include "ompi/proc/proc.h"
+
+#include "mpi.h"
+
+static void check_committed_size(const char *what, MPI_Datatype t, MPI_Aint expect_size);
+
+static void test_contiguous(void);
+static void test_vector(void);
+static void test_indexed(void);
+static void test_struct(void);
+static void test_subarray(void);
+static void test_darray(void);
+static void test_dup_and_name(void);
+static void test_envelope_contents(void);
+static void test_get_contents_c(void);
+static void test_match_size(void);
+static void test_resized(void);
+static void test_pack_unpack(void);
+static void test_pack_external(void);
+static void test_get_elements(void);
+static void test_pack_description(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi datatype");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    /* Route MPI errors back as return codes instead of aborting.  Errors in
+     * the datatype functions are not attached to a handle, so they invoke the
+     * default communicator's error handler (MPI_COMM_WORLD in MPI-3 compat
+     * mode); with MPI_ERRORS_RETURN a failure -- e.g. MPI_Type_match_size
+     * finding no match -- surfaces through test_verify instead of aborting
+     * this launcher-less singleton. */
+    MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN);
+
+    test_contiguous();
+    test_vector();
+    test_indexed();
+    test_struct();
+    test_subarray();
+    test_darray();
+    test_dup_and_name();
+    test_envelope_contents();
+    test_get_contents_c();
+    test_match_size();
+    test_resized();
+    test_pack_unpack();
+    test_pack_external();
+    test_get_elements();
+    test_pack_description();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+/* Commit a derived type, verify its packed size, then free it. */
+static void check_committed_size(const char *what, MPI_Datatype t, MPI_Aint expect_size)
+{
+    int rc = MPI_Type_commit(&t);
+    test_verify(what, MPI_SUCCESS == rc);
+
+    int size = -1;
+    MPI_Type_size(t, &size);
+    test_verify("type packed size matches", (int) expect_size == size);
+
+    MPI_Aint lb = 0, extent = 0;
+    rc = MPI_Type_get_extent(t, &lb, &extent);
+    test_verify("Type_get_extent succeeds", MPI_SUCCESS == rc);
+
+    MPI_Type_free(&t);
+    test_verify("Type_free sets handle to MPI_DATATYPE_NULL", MPI_DATATYPE_NULL == t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_contiguous(void)
+{
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_contiguous(4, MPI_INT, &t);
+    test_verify("Type_contiguous succeeds", MPI_SUCCESS == rc);
+    check_committed_size("contiguous commit", t, 4 * sizeof(int));
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_vector(void)
+{
+    /* 2 blocks of 3 ints, stride 5 ints */
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_vector(2, 3, 5, MPI_INT, &t);
+    test_verify("Type_vector succeeds", MPI_SUCCESS == rc);
+    check_committed_size("vector commit", t, 2 * 3 * sizeof(int));
+
+    MPI_Datatype h = MPI_DATATYPE_NULL;
+    rc = MPI_Type_create_hvector(2, 3, 5 * sizeof(int), MPI_INT, &h);
+    test_verify("Type_create_hvector succeeds", MPI_SUCCESS == rc);
+    check_committed_size("hvector commit", h, 2 * 3 * sizeof(int));
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_indexed(void)
+{
+    int blens[2] = {1, 2};
+    int displs[2] = {0, 3};
+
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_indexed(2, blens, displs, MPI_INT, &t);
+    test_verify("Type_indexed succeeds", MPI_SUCCESS == rc);
+    check_committed_size("indexed commit", t, 3 * sizeof(int));
+
+    MPI_Aint hdispls[2] = {0, 3 * sizeof(int)};
+    MPI_Datatype h = MPI_DATATYPE_NULL;
+    rc = MPI_Type_create_hindexed(2, blens, hdispls, MPI_INT, &h);
+    test_verify("Type_create_hindexed succeeds", MPI_SUCCESS == rc);
+    check_committed_size("hindexed commit", h, 3 * sizeof(int));
+
+    MPI_Datatype b = MPI_DATATYPE_NULL;
+    rc = MPI_Type_create_indexed_block(2, 2, displs, MPI_INT, &b);
+    test_verify("Type_create_indexed_block succeeds", MPI_SUCCESS == rc);
+    check_committed_size("indexed_block commit", b, 2 * 2 * sizeof(int));
+
+    MPI_Datatype hb = MPI_DATATYPE_NULL;
+    rc = MPI_Type_create_hindexed_block(2, 2, hdispls, MPI_INT, &hb);
+    test_verify("Type_create_hindexed_block succeeds", MPI_SUCCESS == rc);
+    check_committed_size("hindexed_block commit", hb, 2 * 2 * sizeof(int));
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_struct(void)
+{
+    int blens[2] = {1, 1};
+    MPI_Aint displs[2] = {0, sizeof(int)};
+    MPI_Datatype types[2] = {MPI_INT, MPI_CHAR};
+
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_create_struct(2, blens, displs, types, &t);
+    test_verify("Type_create_struct succeeds", MPI_SUCCESS == rc);
+    check_committed_size("struct commit", t, sizeof(int) + sizeof(char));
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_subarray(void)
+{
+    int sizes[2] = {4, 4};
+    int subsizes[2] = {2, 2};
+    int starts[2] = {1, 1};
+
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_create_subarray(2, sizes, subsizes, starts,
+                                      MPI_ORDER_C, MPI_INT, &t);
+    test_verify("Type_create_subarray succeeds", MPI_SUCCESS == rc);
+    check_committed_size("subarray commit", t, 2 * 2 * sizeof(int));
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_darray(void)
+{
+    /* singleton: 1 process, so the local block is the whole array */
+    int gsizes[1] = {8};
+    int distribs[1] = {MPI_DISTRIBUTE_BLOCK};
+    int dargs[1] = {MPI_DISTRIBUTE_DFLT_DARG};
+    int psizes[1] = {1};
+
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_create_darray(1, 0, 1, gsizes, distribs, dargs, psizes,
+                                    MPI_ORDER_C, MPI_INT, &t);
+    test_verify("Type_create_darray succeeds", MPI_SUCCESS == rc);
+    check_committed_size("darray commit", t, 8 * sizeof(int));
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_dup_and_name(void)
+{
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    MPI_Type_contiguous(2, MPI_DOUBLE, &t);
+    MPI_Type_commit(&t);
+
+    MPI_Datatype dup = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_dup(t, &dup);
+    test_verify("Type_dup succeeds", MPI_SUCCESS == rc);
+
+    int dsize = -1, osize = -1;
+    MPI_Type_size(dup, &dsize);
+    MPI_Type_size(t, &osize);
+    test_verify("dup has same size as original", dsize == osize);
+
+    rc = MPI_Type_set_name(dup, "mydup");
+    test_verify("Type_set_name succeeds", MPI_SUCCESS == rc);
+    char name[MPI_MAX_OBJECT_NAME];
+    int len = -1;
+    MPI_Type_get_name(dup, name, &len);
+    test_verify("Type_get_name round-trips", 0 == strcmp(name, "mydup"));
+
+    MPI_Type_free(&dup);
+    MPI_Type_free(&t);
+}
+
+/* ------------------------------------------------------------------ */
+
+/* Free any returned constituent types that are derived (predefined
+ * types must not be freed). */
+static void free_returned_types(MPI_Datatype *types, int n)
+{
+    for (int i = 0; i < n; ++i) {
+        int ni, na, nt, comb;
+        MPI_Type_get_envelope(types[i], &ni, &na, &nt, &comb);
+        if (MPI_COMBINER_NAMED != comb) {
+            MPI_Type_free(&types[i]);
+        }
+    }
+}
+
+/*
+ * Round-trip a committed derived type through get_envelope + get_contents,
+ * verifying the reported combiner.  Exercises the decode side of
+ * ompi_datatype_args.c for every combiner.  Output arrays are intentionally
+ * oversized (valid per the MPI standard).
+ */
+static void check_envelope(const char *what, MPI_Datatype t, int expect_combiner)
+{
+    int ni = -1, na = -1, nt = -1, combiner = -1;
+    int rc = MPI_Type_get_envelope(t, &ni, &na, &nt, &combiner);
+    test_verify(what, MPI_SUCCESS == rc && expect_combiner == combiner);
+
+    int ints[32];
+    MPI_Aint addrs[32];
+    MPI_Datatype types[32];
+    rc = MPI_Type_get_contents(t, 32, 32, 32, ints, addrs, types);
+    test_verify("get_contents succeeds", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS == rc) {
+        free_returned_types(types, nt);
+    }
+
+    /* Also exercise the large-count form (MPI_Type_get_contents_c) with
+     * oversized output arrays: it shares the same loop-bound fix, where the
+     * constituent-datatype fix-up must iterate over the actual count, not the
+     * caller-provided max_datatypes. */
+    int cints[32];
+    MPI_Aint caddrs[32];
+    MPI_Count ccounts[32];
+    MPI_Datatype ctypes[32];
+    rc = MPI_Type_get_contents_c(t, 32, 32, 32, 32, cints, caddrs, ccounts, ctypes);
+    test_verify("get_contents_c succeeds", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS == rc) {
+        free_returned_types(ctypes, nt);
+    }
+}
+
+static void test_envelope_contents(void)
+{
+    /* named predefined type */
+    int ni, na, nt, combiner = -1;
+    MPI_Type_get_envelope(MPI_INT, &ni, &na, &nt, &combiner);
+    test_verify("predefined type combiner is MPI_COMBINER_NAMED",
+                MPI_COMBINER_NAMED == combiner);
+
+    int blens[2] = {1, 2};
+    int displs[2] = {0, 3};
+    MPI_Aint hdispls[2] = {0, 3 * sizeof(int)};
+    MPI_Datatype memb[2] = {MPI_INT, MPI_CHAR};
+    int sizes[2] = {4, 4}, subsizes[2] = {2, 2}, starts[2] = {0, 0};
+    int gsizes[1] = {4}, distribs[1] = {MPI_DISTRIBUTE_BLOCK};
+    int dargs[1] = {MPI_DISTRIBUTE_DFLT_DARG}, psizes[1] = {1};
+
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+
+    MPI_Type_contiguous(4, MPI_INT, &t); MPI_Type_commit(&t);
+    check_envelope("contiguous combiner", t, MPI_COMBINER_CONTIGUOUS);
+    MPI_Type_free(&t);
+
+    MPI_Type_vector(2, 3, 5, MPI_INT, &t); MPI_Type_commit(&t);
+    check_envelope("vector combiner", t, MPI_COMBINER_VECTOR);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_hvector(2, 3, 20, MPI_INT, &t); MPI_Type_commit(&t);
+    check_envelope("hvector combiner", t, MPI_COMBINER_HVECTOR);
+    MPI_Type_free(&t);
+
+    MPI_Type_indexed(2, blens, displs, MPI_INT, &t); MPI_Type_commit(&t);
+    check_envelope("indexed combiner", t, MPI_COMBINER_INDEXED);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_hindexed(2, blens, hdispls, MPI_INT, &t); MPI_Type_commit(&t);
+    check_envelope("hindexed combiner", t, MPI_COMBINER_HINDEXED);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_indexed_block(2, 2, displs, MPI_INT, &t); MPI_Type_commit(&t);
+    check_envelope("indexed_block combiner", t, MPI_COMBINER_INDEXED_BLOCK);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_hindexed_block(2, 2, hdispls, MPI_INT, &t); MPI_Type_commit(&t);
+    check_envelope("hindexed_block combiner", t, MPI_COMBINER_HINDEXED_BLOCK);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_struct(2, blens, hdispls, memb, &t); MPI_Type_commit(&t);
+    check_envelope("struct combiner", t, MPI_COMBINER_STRUCT);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_subarray(2, sizes, subsizes, starts, MPI_ORDER_C, MPI_INT, &t);
+    MPI_Type_commit(&t);
+    check_envelope("subarray combiner", t, MPI_COMBINER_SUBARRAY);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_darray(1, 0, 1, gsizes, distribs, dargs, psizes,
+                           MPI_ORDER_C, MPI_INT, &t);
+    MPI_Type_commit(&t);
+    check_envelope("darray combiner", t, MPI_COMBINER_DARRAY);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_resized(MPI_INT, 0, 8, &t); MPI_Type_commit(&t);
+    check_envelope("resized combiner", t, MPI_COMBINER_RESIZED);
+    MPI_Type_free(&t);
+
+    MPI_Datatype base = MPI_DATATYPE_NULL;
+    MPI_Type_contiguous(2, MPI_INT, &base); MPI_Type_commit(&base);
+    MPI_Type_dup(base, &t); MPI_Type_commit(&t);
+    check_envelope("dup combiner", t, MPI_COMBINER_DUP);
+    MPI_Type_free(&t);
+    MPI_Type_free(&base);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * Exercise the large-count contents path explicitly.  A datatype built with
+ * an "_c" constructor stores its count in array_of_large_counts (not
+ * array_of_integers), so MPI_Type_get_contents_c must return that value.  The
+ * output arrays are oversized, which also covers the loop-bound fix on the _c
+ * path (the constituent-datatype fix-up must iterate over the actual count,
+ * not the caller-provided max_datatypes).
+ */
+static void test_get_contents_c(void)
+{
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_contiguous_c(7, MPI_INT, &t);
+    test_verify("Type_contiguous_c succeeds", MPI_SUCCESS == rc && MPI_DATATYPE_NULL != t);
+    MPI_Type_commit(&t);
+
+    MPI_Count ni = -1, na = -1, nc = -1, nt = -1;
+    int combiner = -1;
+    MPI_Type_get_envelope_c(t, &ni, &na, &nc, &nt, &combiner);
+    test_verify("get_envelope_c reports CONTIGUOUS", MPI_COMBINER_CONTIGUOUS == combiner);
+    test_verify("get_envelope_c reports one large count", 1 == nc);
+    test_verify("get_envelope_c reports one constituent datatype", 1 == nt);
+
+    int cints[32];
+    MPI_Aint caddrs[32];
+    MPI_Count ccounts[32];
+    MPI_Datatype ctypes[32];
+    rc = MPI_Type_get_contents_c(t, 32, 32, 32, 32, cints, caddrs, ccounts, ctypes);
+    test_verify("get_contents_c succeeds", MPI_SUCCESS == rc);
+    test_verify("get_contents_c returns the large count in array_of_large_counts",
+                7 == ccounts[0]);
+    test_verify("get_contents_c returns the constituent datatype", MPI_INT == ctypes[0]);
+    if (MPI_SUCCESS == rc) {
+        free_returned_types(ctypes, (int) nt);
+    }
+
+    MPI_Type_free(&t);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * MPI_Type_match_size maps a (typeclass, size) pair to an *intrinsic Fortran*
+ * predefined datatype: the C binding forces the Fortran language flag, so it
+ * resolves Fortran intrinsic types regardless of the calling language.  It
+ * must return a scalar intrinsic of the requested size -- never a C type, an
+ * "unavailable" type, or a composite type such as MPI_2REAL.
+ *
+ * This test asserts the behavior that is correct for the build as configured
+ * (it is not a workaround to make the test pass):
+ *
+ *   - With the Fortran bindings built, each request must succeed and return
+ *     the expected scalar intrinsic of the requested size.
+ *   - With --disable-mpi-fortran the intrinsic types are unavailable, so per
+ *     MPI-5.0 19.1 ("erroneous to specify a size not supported by the
+ *     compiler") each request must fail (MPI_ERRORS_RETURN is set in main()).
+ */
+static void test_match_size(void)
+{
+    MPI_Datatype t;
+    int rc, size;
+
+    t = MPI_DATATYPE_NULL;
+    rc = MPI_Type_match_size(MPI_TYPECLASS_REAL, (int) sizeof(double), &t);
+#if OMPI_BUILD_FORTRAN_BINDINGS
+    test_verify("Type_match_size(REAL, sizeof(double)) succeeds",
+                MPI_SUCCESS == rc && MPI_DATATYPE_NULL != t);
+    test_verify("Type_match_size(REAL, sizeof(double)) returns a scalar real intrinsic (not a composite)",
+                MPI_REAL8 == t || MPI_DOUBLE_PRECISION == t);
+    size = -1;
+    MPI_Type_size(t, &size);
+    test_verify("matched real type has the requested size", (int) sizeof(double) == size);
+#else
+    test_verify("Type_match_size(REAL, sizeof(double)) fails without Fortran support",
+                MPI_SUCCESS != rc);
+#endif
+
+    t = MPI_DATATYPE_NULL;
+    rc = MPI_Type_match_size(MPI_TYPECLASS_INTEGER, (int) sizeof(int), &t);
+#if OMPI_BUILD_FORTRAN_BINDINGS
+    test_verify("Type_match_size(INTEGER, sizeof(int)) succeeds",
+                MPI_SUCCESS == rc && MPI_DATATYPE_NULL != t);
+    test_verify("Type_match_size(INTEGER, sizeof(int)) returns a scalar integer intrinsic",
+                MPI_INTEGER == t || MPI_INTEGER4 == t);
+    size = -1;
+    MPI_Type_size(t, &size);
+    test_verify("matched integer type has the requested size", (int) sizeof(int) == size);
+#else
+    test_verify("Type_match_size(INTEGER, sizeof(int)) fails without Fortran support",
+                MPI_SUCCESS != rc);
+#endif
+
+    t = MPI_DATATYPE_NULL;
+    rc = MPI_Type_match_size(MPI_TYPECLASS_COMPLEX, (int) (2 * sizeof(float)), &t);
+#if OMPI_BUILD_FORTRAN_BINDINGS
+    test_verify("Type_match_size(COMPLEX, 2*sizeof(float)) succeeds",
+                MPI_SUCCESS == rc && MPI_DATATYPE_NULL != t);
+    test_verify("Type_match_size(COMPLEX, 2*sizeof(float)) returns a scalar complex intrinsic",
+                MPI_COMPLEX == t || MPI_COMPLEX8 == t);
+    size = -1;
+    MPI_Type_size(t, &size);
+    test_verify("matched complex type has the requested size", (int) (2 * sizeof(float)) == size);
+#else
+    test_verify("Type_match_size(COMPLEX, 2*sizeof(float)) fails without Fortran support",
+                MPI_SUCCESS != rc);
+#endif
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_resized(void)
+{
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+    int rc = MPI_Type_create_resized(MPI_INT, 0, 8, &t);
+    test_verify("Type_create_resized succeeds", MPI_SUCCESS == rc);
+    MPI_Type_commit(&t);
+
+    MPI_Aint lb = -1, extent = -1;
+    MPI_Type_get_extent(t, &lb, &extent);
+    test_verify("resized lb is 0", 0 == lb);
+    test_verify("resized extent is 8", 8 == extent);
+
+    int size = -1;
+    MPI_Type_size(t, &size);
+    test_verify("resized size is unchanged (sizeof int)", (int) sizeof(int) == size);
+
+    MPI_Type_free(&t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_pack_unpack(void)
+{
+    int in[3] = {11, 22, 33};
+    int packsize = -1;
+    int rc = MPI_Pack_size(3, MPI_INT, MPI_COMM_SELF, &packsize);
+    test_verify("Pack_size succeeds", MPI_SUCCESS == rc);
+    test_verify("pack size is at least 3 ints", packsize >= (int) (3 * sizeof(int)));
+
+    char buf[128];
+    int pos = 0;
+    rc = MPI_Pack(in, 3, MPI_INT, buf, sizeof(buf), &pos, MPI_COMM_SELF);
+    test_verify("Pack succeeds", MPI_SUCCESS == rc);
+    test_verify("pack advanced the position", pos > 0);
+
+    int out[3] = {0, 0, 0};
+    int pos2 = 0;
+    rc = MPI_Unpack(buf, sizeof(buf), &pos2, out, 3, MPI_INT, MPI_COMM_SELF);
+    test_verify("Unpack succeeds", MPI_SUCCESS == rc);
+    test_verify("unpacked data matches", 11 == out[0] && 22 == out[1] && 33 == out[2]);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_pack_external(void)
+{
+    int in[3] = {7, 8, 9};
+    MPI_Aint extsize = -1;
+    int rc = MPI_Pack_external_size("external32", 3, MPI_INT, &extsize);
+    test_verify("Pack_external_size succeeds", MPI_SUCCESS == rc);
+    test_verify("external32 size is 3 * 4 bytes", 12 == extsize);
+
+    char buf[128];
+    MPI_Aint pos = 0;
+    rc = MPI_Pack_external("external32", in, 3, MPI_INT, buf, sizeof(buf), &pos);
+    test_verify("Pack_external succeeds", MPI_SUCCESS == rc);
+
+    int out[3] = {0, 0, 0};
+    MPI_Aint pos2 = 0;
+    rc = MPI_Unpack_external("external32", buf, sizeof(buf), &pos2, out, 3, MPI_INT);
+    test_verify("Unpack_external succeeds", MPI_SUCCESS == rc);
+    test_verify("external32 round-trip matches", 7 == out[0] && 8 == out[1] && 9 == out[2]);
+}
+
+/* ------------------------------------------------------------------ */
+
+/* MPI_Get_elements / MPI_Get_count need a status; obtain one from a
+ * self MPI_Sendrecv on MPI_COMM_SELF (valid single-process). */
+static void test_get_elements(void)
+{
+    int sbuf[6] = {1, 2, 3, 4, 5, 6};
+    int rbuf[6] = {0};
+    MPI_Status status;
+    int rc = MPI_Sendrecv(sbuf, 6, MPI_INT, 0, 0,
+                          rbuf, 6, MPI_INT, 0, 0, MPI_COMM_SELF, &status);
+    test_verify("self Sendrecv succeeds", MPI_SUCCESS == rc);
+
+    int count = -1;
+    rc = MPI_Get_count(&status, MPI_INT, &count);
+    test_verify("Get_count succeeds", MPI_SUCCESS == rc);
+    test_verify("Get_count returns 6", 6 == count);
+
+    int elems = -1;
+    rc = MPI_Get_elements(&status, MPI_INT, &elems);
+    test_verify("Get_elements succeeds", MPI_SUCCESS == rc);
+    test_verify("Get_elements returns 6", 6 == elems);
+
+    MPI_Count elems_x = -1;
+    rc = MPI_Get_elements_x(&status, MPI_INT, &elems_x);
+    test_verify("Get_elements_x succeeds", MPI_SUCCESS == rc);
+    test_verify("Get_elements_x returns 6", 6 == elems_x);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * Exercise the datatype serialization machinery in ompi_datatype_args.c
+ * (get_pack_description -> create_from_packed_description, i.e. the
+ * encode/decode path normally used to ship derived types between ranks).
+ * This is driven single-process by packing a type's description and
+ * reconstructing it locally against the local proc.
+ */
+static void roundtrip_pack(const char *what, MPI_Datatype t)
+{
+    ompi_datatype_t *dt = (ompi_datatype_t *) t;
+
+    size_t len = ompi_datatype_pack_description_length(dt);
+    test_verify("pack_description_length is non-zero", len > 0);
+
+    const void *packed = NULL;
+    int rc = ompi_datatype_get_pack_description(dt, &packed);
+    test_verify(what, OMPI_SUCCESS == rc && NULL != packed);
+    if (OMPI_SUCCESS != rc || NULL == packed) {
+        return;
+    }
+
+    /* create_from_packed_description advances the buffer pointer, so work
+     * on a mutable copy. */
+    void *buf = malloc(len);
+    memcpy(buf, packed, len);
+    void *ptr = buf;
+
+    ompi_datatype_t *recon =
+        ompi_datatype_create_from_packed_description(&ptr, ompi_proc_local());
+    test_verify("create_from_packed_description succeeds", NULL != recon);
+    if (NULL != recon) {
+        int sz_orig = -1, sz_recon = -1;
+        MPI_Type_size(t, &sz_orig);
+        MPI_Type_size((MPI_Datatype) recon, &sz_recon);
+        test_verify("reconstructed type has the same size", sz_orig == sz_recon);
+
+        MPI_Datatype mr = (MPI_Datatype) recon;
+        MPI_Type_free(&mr);
+    }
+    free(buf);
+}
+
+static void test_pack_description(void)
+{
+    int blens[2] = {1, 2};
+    int displs[2] = {0, 3};
+    MPI_Aint hdispls[2] = {0, 3 * sizeof(int)};
+    MPI_Datatype memb[2] = {MPI_INT, MPI_DOUBLE};
+
+    MPI_Datatype t = MPI_DATATYPE_NULL;
+
+    MPI_Type_contiguous(4, MPI_INT, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (contiguous) succeeds", t);
+    MPI_Type_free(&t);
+
+    MPI_Type_vector(2, 3, 5, MPI_DOUBLE, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (vector) succeeds", t);
+    MPI_Type_free(&t);
+
+    MPI_Type_indexed(2, blens, displs, MPI_INT, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (indexed) succeeds", t);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_struct(2, blens, hdispls, memb, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (struct) succeeds", t);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_hvector(2, 3, 20, MPI_INT, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (hvector) succeeds", t);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_hindexed(2, blens, hdispls, MPI_INT, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (hindexed) succeeds", t);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_indexed_block(2, 2, displs, MPI_INT, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (indexed_block) succeeds", t);
+    MPI_Type_free(&t);
+
+    MPI_Type_create_hindexed_block(2, 2, hdispls, MPI_INT, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (hindexed_block) succeeds", t);
+    MPI_Type_free(&t);
+
+    {
+        int sizes[2] = {4, 4}, subsizes[2] = {2, 2}, starts[2] = {0, 0};
+        MPI_Type_create_subarray(2, sizes, subsizes, starts, MPI_ORDER_C, MPI_INT, &t);
+        MPI_Type_commit(&t);
+        roundtrip_pack("get_pack_description (subarray) succeeds", t);
+        MPI_Type_free(&t);
+    }
+
+    MPI_Type_create_resized(MPI_INT, 0, 16, &t); MPI_Type_commit(&t);
+    roundtrip_pack("get_pack_description (resized) succeeds", t);
+    MPI_Type_free(&t);
+
+    {
+        /* nested: a contiguous of a vector exercises recursive packing */
+        MPI_Datatype base = MPI_DATATYPE_NULL;
+        MPI_Type_vector(2, 2, 3, MPI_DOUBLE, &base); MPI_Type_commit(&base);
+        MPI_Type_contiguous(3, base, &t); MPI_Type_commit(&t);
+        roundtrip_pack("get_pack_description (nested) succeeds", t);
+        MPI_Type_free(&t);
+        MPI_Type_free(&base);
+    }
+}
diff --git a/ompi/test/general/errhandler.c b/ompi/test/general/errhandler.c
new file mode 100644
index 00000000000..78875e06f92
--- /dev/null
+++ b/ompi/test/general/errhandler.c
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/errhandler layer (errhandler.c,
+ * errhandler_invoke.c, errcode.c, errcode-internal.c).  Exercised
+ * through the public MPI error-handler and error-code API after a full
+ * singleton MPI_Init.  Custom handlers use MPI_*_call_errhandler so the
+ * invoke path runs without actually aborting.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <string.h>
+
+#include "support.h"
+
+#include "mpi.h"
+
+static int comm_eh_calls = 0;
+static int comm_eh_last_code = 0;
+
+static void comm_errhandler(MPI_Comm *comm, int *code, ...)
+{
+    (void) comm;
+    ++comm_eh_calls;
+    comm_eh_last_code = *code;
+}
+
+static void test_comm_errhandler(void);
+static void test_predefined_errhandlers(void);
+static void test_win_errhandler(void);
+static void test_error_codes(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi errhandler");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_comm_errhandler();
+    test_predefined_errhandlers();
+    test_win_errhandler();
+    test_error_codes();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_comm_errhandler(void)
+{
+    MPI_Errhandler eh = MPI_ERRHANDLER_NULL;
+    int rc = MPI_Comm_create_errhandler(comm_errhandler, &eh);
+    test_verify("Comm_create_errhandler succeeds", MPI_SUCCESS == rc);
+    test_verify("created errhandler is non-NULL", MPI_ERRHANDLER_NULL != eh);
+
+    MPI_Comm comm = MPI_COMM_NULL;
+    MPI_Comm_dup(MPI_COMM_WORLD, &comm);
+
+    rc = MPI_Comm_set_errhandler(comm, eh);
+    test_verify("Comm_set_errhandler succeeds", MPI_SUCCESS == rc);
+
+    MPI_Errhandler got = MPI_ERRHANDLER_NULL;
+    rc = MPI_Comm_get_errhandler(comm, &got);
+    test_verify("Comm_get_errhandler succeeds", MPI_SUCCESS == rc);
+    test_verify("get_errhandler returns the one we set", got == eh);
+    MPI_Errhandler_free(&got); /* get_errhandler increments the refcount */
+
+    comm_eh_calls = 0;
+    comm_eh_last_code = 0;
+    rc = MPI_Comm_call_errhandler(comm, MPI_ERR_OTHER);
+    test_verify("Comm_call_errhandler succeeds", MPI_SUCCESS == rc);
+    test_verify("custom errhandler was invoked", 1 == comm_eh_calls);
+    test_verify("errhandler saw the right error code", MPI_ERR_OTHER == comm_eh_last_code);
+
+    MPI_Comm_free(&comm);
+    rc = MPI_Errhandler_free(&eh);
+    test_verify("Errhandler_free succeeds", MPI_SUCCESS == rc);
+    test_verify("Errhandler_free NULLs the handle", MPI_ERRHANDLER_NULL == eh);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_predefined_errhandlers(void)
+{
+    test_verify("MPI_ERRORS_RETURN is non-NULL", MPI_ERRHANDLER_NULL != MPI_ERRORS_RETURN);
+    test_verify("MPI_ERRORS_ARE_FATAL is non-NULL",
+                MPI_ERRHANDLER_NULL != MPI_ERRORS_ARE_FATAL);
+
+    MPI_Comm comm = MPI_COMM_NULL;
+    MPI_Comm_dup(MPI_COMM_WORLD, &comm);
+
+    int rc = MPI_Comm_set_errhandler(comm, MPI_ERRORS_RETURN);
+    test_verify("setting MPI_ERRORS_RETURN succeeds", MPI_SUCCESS == rc);
+
+    MPI_Errhandler got = MPI_ERRHANDLER_NULL;
+    MPI_Comm_get_errhandler(comm, &got);
+    test_verify("get returns MPI_ERRORS_RETURN", got == MPI_ERRORS_RETURN);
+    MPI_Errhandler_free(&got);
+
+    /* invoking MPI_ERRORS_RETURN must not abort */
+    rc = MPI_Comm_call_errhandler(comm, MPI_ERR_OTHER);
+    test_verify("calling MPI_ERRORS_RETURN returns cleanly", MPI_SUCCESS == rc);
+
+    MPI_Comm_free(&comm);
+}
+
+/* ------------------------------------------------------------------ */
+
+static int win_eh_calls = 0;
+
+static void win_errhandler(MPI_Win *win, int *code, ...)
+{
+    (void) win; (void) code;
+    ++win_eh_calls;
+}
+
+static void test_win_errhandler(void)
+{
+    static int buffer[8];
+    MPI_Win win = MPI_WIN_NULL;
+    int rc = MPI_Win_create(buffer, sizeof(buffer), sizeof(int),
+                            MPI_INFO_NULL, MPI_COMM_SELF, &win);
+    test_verify("Win_create succeeds", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS != rc || MPI_WIN_NULL == win) {
+        return;
+    }
+
+    MPI_Errhandler eh = MPI_ERRHANDLER_NULL;
+    rc = MPI_Win_create_errhandler(win_errhandler, &eh);
+    test_verify("Win_create_errhandler succeeds", MPI_SUCCESS == rc);
+
+    rc = MPI_Win_set_errhandler(win, eh);
+    test_verify("Win_set_errhandler succeeds", MPI_SUCCESS == rc);
+
+    MPI_Errhandler got = MPI_ERRHANDLER_NULL;
+    rc = MPI_Win_get_errhandler(win, &got);
+    test_verify("Win_get_errhandler succeeds", MPI_SUCCESS == rc);
+    test_verify("Win_get_errhandler returns the one we set", got == eh);
+    if (MPI_ERRHANDLER_NULL != got) {
+        MPI_Errhandler_free(&got);
+    }
+
+    win_eh_calls = 0;
+    rc = MPI_Win_call_errhandler(win, MPI_ERR_OTHER);
+    test_verify("Win_call_errhandler succeeds", MPI_SUCCESS == rc);
+    test_verify("custom window errhandler was invoked", 1 == win_eh_calls);
+
+    MPI_Win_free(&win);
+    MPI_Errhandler_free(&eh);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_error_codes(void)
+{
+    /* error class of a predefined code is the code itself */
+    int eclass = -1;
+    int rc = MPI_Error_class(MPI_ERR_TRUNCATE, &eclass);
+    test_verify("Error_class succeeds", MPI_SUCCESS == rc);
+    test_verify("class of MPI_ERR_TRUNCATE is MPI_ERR_TRUNCATE",
+                MPI_ERR_TRUNCATE == eclass);
+
+    char str[MPI_MAX_ERROR_STRING];
+    int len = -1;
+    rc = MPI_Error_string(MPI_SUCCESS, str, &len);
+    test_verify("Error_string(MPI_SUCCESS) succeeds", MPI_SUCCESS == rc);
+    test_verify("Error_string returns a non-empty string", len > 0);
+
+    /* user-defined error class/code/string */
+    int newclass = -1;
+    rc = MPI_Add_error_class(&newclass);
+    test_verify("Add_error_class succeeds", MPI_SUCCESS == rc);
+    test_verify("new class is beyond MPI_ERR_LASTCODE", newclass > MPI_ERR_LASTCODE);
+
+    int newcode = -1;
+    rc = MPI_Add_error_code(newclass, &newcode);
+    test_verify("Add_error_code succeeds", MPI_SUCCESS == rc);
+
+    rc = MPI_Add_error_string(newcode, "my custom error");
+    test_verify("Add_error_string succeeds", MPI_SUCCESS == rc);
+
+    memset(str, 0, sizeof(str));
+    len = -1;
+    MPI_Error_string(newcode, str, &len);
+    test_verify("custom error string round-trips",
+                0 == strcmp(str, "my custom error"));
+
+    int c2 = -1;
+    MPI_Error_class(newcode, &c2);
+    test_verify("class of the new code is the new class", newclass == c2);
+}
diff --git a/ompi/test/general/file.c b/ompi/test/general/file.c
new file mode 100644
index 00000000000..adeda34d05d
--- /dev/null
+++ b/ompi/test/general/file.c
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/file layer (file.c): the MPI_File object
+ * lifecycle, exercised via MPI-IO on a local temp file opened on
+ * MPI_COMM_SELF (single process).  Covers open/close, amode, group,
+ * name, info, view, atomicity, errhandler, plus a small write/read and
+ * file delete.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "support.h"
+
+#include "mpi.h"
+
+#define TEST_FILE_NAME "ompi_file_test.dat"
+
+static int file_eh_calls = 0;
+
+static void file_errhandler(MPI_File *fh, int *code, ...)
+{
+    (void) fh; (void) code;
+    ++file_eh_calls;
+}
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi file");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    /* Make MPI-IO errors return rather than abort the test. */
+    MPI_File_set_errhandler(MPI_FILE_NULL, MPI_ERRORS_RETURN);
+
+    MPI_File fh = MPI_FILE_NULL;
+    rc = MPI_File_open(MPI_COMM_SELF, TEST_FILE_NAME,
+                       MPI_MODE_CREATE | MPI_MODE_RDWR, MPI_INFO_NULL, &fh);
+    test_verify("File_open succeeds", MPI_SUCCESS == rc && MPI_FILE_NULL != fh);
+    if (MPI_SUCCESS != rc || MPI_FILE_NULL == fh) {
+        /*
+         * The open failure has already been recorded above (this test
+         * fails -- it does not skip).  Without a valid file handle the
+         * remaining operations would dereference MPI_FILE_NULL and (for
+         * the non-file calls below, e.g. on the resulting group) invoke
+         * MPI_COMM_WORLD's default, fatal error handler -- aborting the
+         * process instead of reporting a clean failure.  Stop here so the
+         * recorded failure is what surfaces, after emitting a hint about a
+         * common environmental cause.
+         */
+        char errstr[MPI_MAX_ERROR_STRING] = {0};
+        int errlen = 0;
+        MPI_Error_string(rc, errstr, &errlen);
+        fprintf(stderr,
+                "\n[ompi file test] MPI_File_open failed: %s\n"
+                "[ompi file test] HINT: in a restricted/sandboxed environment "
+                "(e.g. some LLM coding\n"
+                "[ompi file test] harnesses), notably on macOS, ompio's default "
+                "shared-file-pointer\n"
+                "[ompi file test] component \"sm\" cannot create the POSIX named "
+                "semaphore it needs\n"
+                "[ompi file test] (sem_open -> EPERM).  To check whether that is "
+                "the cause, re-run\n"
+                "[ompi file test] with the sm component disabled:\n"
+                "[ompi file test]     OMPI_MCA_sharedfp=^sm <test-program>\n"
+                "[ompi file test] If that makes the test pass, the failure is an "
+                "environment\n"
+                "[ompi file test] limitation, not an Open MPI bug.\n\n",
+                errstr);
+        int r = test_finalize();
+        MPI_Finalize();
+        return r;
+    }
+
+    int amode = 0;
+    rc = MPI_File_get_amode(fh, &amode);
+    test_verify("File_get_amode succeeds", MPI_SUCCESS == rc);
+    test_verify("amode includes MPI_MODE_RDWR", 0 != (amode & MPI_MODE_RDWR));
+
+    MPI_Group grp = MPI_GROUP_NULL;
+    rc = MPI_File_get_group(fh, &grp);
+    test_verify("File_get_group succeeds", MPI_SUCCESS == rc);
+    int gsize = -1;
+    MPI_Group_size(grp, &gsize);
+    test_verify("file group size is 1", 1 == gsize);
+    MPI_Group_free(&grp);
+
+    /* custom file error handler via call_errhandler */
+    MPI_Errhandler eh = MPI_ERRHANDLER_NULL;
+    rc = MPI_File_create_errhandler(file_errhandler, &eh);
+    test_verify("File_create_errhandler succeeds", MPI_SUCCESS == rc);
+    rc = MPI_File_set_errhandler(fh, eh);
+    test_verify("File_set_errhandler succeeds", MPI_SUCCESS == rc);
+    MPI_Errhandler got = MPI_ERRHANDLER_NULL;
+    MPI_File_get_errhandler(fh, &got);
+    test_verify("File_get_errhandler returns the one we set", got == eh);
+    if (MPI_ERRHANDLER_NULL != got) {
+        MPI_Errhandler_free(&got);
+    }
+    file_eh_calls = 0;
+    MPI_File_call_errhandler(fh, MPI_ERR_OTHER);
+    test_verify("custom file errhandler was invoked", 1 == file_eh_calls);
+    /* restore returning handler before doing real I/O */
+    MPI_File_set_errhandler(fh, MPI_ERRORS_RETURN);
+    MPI_Errhandler_free(&eh);
+
+    /* set_view / get_view */
+    rc = MPI_File_set_view(fh, 0, MPI_INT, MPI_INT, "native", MPI_INFO_NULL);
+    test_verify("File_set_view succeeds", MPI_SUCCESS == rc);
+    MPI_Offset disp = -1;
+    MPI_Datatype etype = MPI_DATATYPE_NULL, ftype = MPI_DATATYPE_NULL;
+    char datarep[MPI_MAX_DATAREP_STRING];
+    rc = MPI_File_get_view(fh, &disp, &etype, &ftype, datarep);
+    test_verify("File_get_view succeeds", MPI_SUCCESS == rc);
+    test_verify("view datarep is native", 0 == strcmp(datarep, "native"));
+
+    /* write then read back */
+    int wbuf[8] = {0, 1, 2, 3, 4, 5, 6, 7};
+    MPI_Status status;
+    rc = MPI_File_write_at(fh, 0, wbuf, 8, MPI_INT, &status);
+    test_verify("File_write_at succeeds", MPI_SUCCESS == rc);
+
+    int rbuf[8] = {0};
+    rc = MPI_File_read_at(fh, 0, rbuf, 8, MPI_INT, &status);
+    test_verify("File_read_at succeeds", MPI_SUCCESS == rc);
+    test_verify("file data round-trips", 0 == memcmp(wbuf, rbuf, sizeof(wbuf)));
+
+    MPI_Offset size = -1;
+    rc = MPI_File_get_size(fh, &size);
+    test_verify("File_get_size succeeds", MPI_SUCCESS == rc);
+    test_verify("file size covers what we wrote", size >= (MPI_Offset) sizeof(wbuf));
+
+    /* atomicity */
+    rc = MPI_File_set_atomicity(fh, 1);
+    test_verify("File_set_atomicity succeeds", MPI_SUCCESS == rc);
+    int atom = -1;
+    MPI_File_get_atomicity(fh, &atom);
+    test_verify("atomicity reads back as set", 1 == atom);
+
+    /* info */
+    MPI_Info info = MPI_INFO_NULL;
+    rc = MPI_File_get_info(fh, &info);
+    test_verify("File_get_info succeeds", MPI_SUCCESS == rc && MPI_INFO_NULL != info);
+    if (MPI_INFO_NULL != info) {
+        MPI_Info_free(&info);
+    }
+
+    /* seek / position */
+    rc = MPI_File_seek(fh, 0, MPI_SEEK_SET);
+    test_verify("File_seek succeeds", MPI_SUCCESS == rc);
+    MPI_Offset pos = -1;
+    MPI_File_get_position(fh, &pos);
+    test_verify("File_get_position after seek-to-0 is 0", 0 == pos);
+
+    rc = MPI_File_close(&fh);
+    test_verify("File_close succeeds", MPI_SUCCESS == rc);
+    test_verify("File_close NULLs the handle", MPI_FILE_NULL == fh);
+
+    rc = MPI_File_delete(TEST_FILE_NAME, MPI_INFO_NULL);
+    test_verify("File_delete succeeds", MPI_SUCCESS == rc);
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
diff --git a/ompi/test/general/group.c b/ompi/test/general/group.c
new file mode 100644
index 00000000000..da1006d4da5
--- /dev/null
+++ b/ompi/test/general/group.c
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/group layer (group.c, group_init.c).  Exercised
+ * through the public MPI_Group API after a full singleton MPI_Init.  The
+ * singleton has a single process, so groups are size 0 or 1, but the
+ * include/exclude/range/set-operation code paths are still exercised.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include "support.h"
+
+#include "mpi.h"
+
+static MPI_Group world_group(void)
+{
+    MPI_Group g = MPI_GROUP_NULL;
+    MPI_Comm_group(MPI_COMM_WORLD, &g);
+    return g;
+}
+
+static int group_size(MPI_Group g)
+{
+    int s = -1;
+    MPI_Group_size(g, &s);
+    return s;
+}
+
+static void test_basic(void);
+static void test_translate_compare(void);
+static void test_incl_excl(void);
+static void test_set_ops(void);
+static void test_ranges(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi group");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_basic();
+    test_translate_compare();
+    test_incl_excl();
+    test_set_ops();
+    test_ranges();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_basic(void)
+{
+    MPI_Group g = world_group();
+    test_verify("Comm_group succeeds", MPI_GROUP_NULL != g);
+
+    int size = -1, rank = -1;
+    MPI_Group_size(g, &size);
+    MPI_Group_rank(g, &rank);
+    test_verify("world group size is 1", 1 == size);
+    test_verify("world group rank is 0", 0 == rank);
+
+    /* MPI_GROUP_EMPTY has size 0 */
+    int esize = -1;
+    MPI_Group_size(MPI_GROUP_EMPTY, &esize);
+    test_verify("MPI_GROUP_EMPTY size is 0", 0 == esize);
+    int erank = 0;
+    MPI_Group_rank(MPI_GROUP_EMPTY, &erank);
+    test_verify("rank in MPI_GROUP_EMPTY is MPI_UNDEFINED", MPI_UNDEFINED == erank);
+
+    MPI_Group_free(&g);
+    test_verify("Group_free sets handle to MPI_GROUP_NULL", MPI_GROUP_NULL == g);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_translate_compare(void)
+{
+    MPI_Group g = world_group();
+
+    int result = -1;
+    MPI_Group_compare(g, g, &result);
+    test_verify("group compared with itself is MPI_IDENT", MPI_IDENT == result);
+
+    result = -1;
+    MPI_Group_compare(g, MPI_GROUP_EMPTY, &result);
+    test_verify("non-equal groups are MPI_UNEQUAL", MPI_UNEQUAL == result);
+
+    int ranks1[1] = {0};
+    int ranks2[1] = {-1};
+    MPI_Group_translate_ranks(g, 1, ranks1, g, ranks2);
+    test_verify("translate_ranks maps rank 0 -> 0", 0 == ranks2[0]);
+
+    MPI_Group_free(&g);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_incl_excl(void)
+{
+    MPI_Group g = world_group();
+
+    int ranks[1] = {0};
+
+    MPI_Group inc = MPI_GROUP_NULL;
+    int rc = MPI_Group_incl(g, 1, ranks, &inc);
+    test_verify("Group_incl succeeds", MPI_SUCCESS == rc);
+    test_verify("incl([0]) has size 1", 1 == group_size(inc));
+
+    MPI_Group exc = MPI_GROUP_NULL;
+    rc = MPI_Group_excl(g, 1, ranks, &exc);
+    test_verify("Group_excl succeeds", MPI_SUCCESS == rc);
+    test_verify("excl([0]) has size 0", 0 == group_size(exc));
+
+    /* incl with zero ranks yields the empty group */
+    MPI_Group inc0 = MPI_GROUP_NULL;
+    rc = MPI_Group_incl(g, 0, NULL, &inc0);
+    test_verify("Group_incl(0) succeeds", MPI_SUCCESS == rc);
+    test_verify("incl(0) has size 0", 0 == group_size(inc0));
+
+    MPI_Group_free(&inc);
+    MPI_Group_free(&exc);
+    MPI_Group_free(&inc0);
+    MPI_Group_free(&g);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_set_ops(void)
+{
+    MPI_Group g = world_group();
+
+    MPI_Group u = MPI_GROUP_NULL;
+    int rc = MPI_Group_union(g, MPI_GROUP_EMPTY, &u);
+    test_verify("Group_union succeeds", MPI_SUCCESS == rc);
+    test_verify("union(world, empty) has size 1", 1 == group_size(u));
+
+    MPI_Group i = MPI_GROUP_NULL;
+    rc = MPI_Group_intersection(g, g, &i);
+    test_verify("Group_intersection succeeds", MPI_SUCCESS == rc);
+    test_verify("intersection(world, world) has size 1", 1 == group_size(i));
+
+    MPI_Group d = MPI_GROUP_NULL;
+    rc = MPI_Group_difference(g, g, &d);
+    test_verify("Group_difference succeeds", MPI_SUCCESS == rc);
+    test_verify("difference(world, world) has size 0", 0 == group_size(d));
+
+    MPI_Group_free(&u);
+    MPI_Group_free(&i);
+    MPI_Group_free(&d);
+    MPI_Group_free(&g);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_ranges(void)
+{
+    MPI_Group g = world_group();
+
+    int range[1][3] = {{0, 0, 1}}; /* first, last, stride */
+
+    MPI_Group ri = MPI_GROUP_NULL;
+    int rc = MPI_Group_range_incl(g, 1, range, &ri);
+    test_verify("Group_range_incl succeeds", MPI_SUCCESS == rc);
+    test_verify("range_incl([0:0:1]) has size 1", 1 == group_size(ri));
+
+    MPI_Group re = MPI_GROUP_NULL;
+    rc = MPI_Group_range_excl(g, 1, range, &re);
+    test_verify("Group_range_excl succeeds", MPI_SUCCESS == rc);
+    test_verify("range_excl([0:0:1]) has size 0", 0 == group_size(re));
+
+    MPI_Group_free(&ri);
+    MPI_Group_free(&re);
+    MPI_Group_free(&g);
+}
diff --git a/ompi/test/general/info.c b/ompi/test/general/info.c
new file mode 100644
index 00000000000..0f464d14ff1
--- /dev/null
+++ b/ompi/test/general/info.c
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2017 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi_info_t wrappers (ompi/info/info.c).  These are
+ * thin wrappers around the opal_info_t implementation, but they also
+ * exercise the ompi_info_t constructor/destructor (which register the
+ * object in the Fortran<->C handle table) plus ompi_mpiinfo_init() /
+ * ompi_mpiinfo_finalize().
+ *
+ * This runs with a *partial* runtime init: opal_init_util() brings up
+ * the OPAL object/finalize machinery, and ompi_mpiinfo_init() sets up
+ * the info handle table.  No full MPI_Init / instance bring-up is
+ * required for the wrapper API.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "support.h"
+
+#include "opal/runtime/opal.h"
+#include "opal/class/opal_cstring.h"
+
+#include "ompi/constants.h"
+#include "ompi/info/info.h"
+
+static void test_set_and_get(void);
+static void test_get_missing_key(void);
+static void test_overwrite(void);
+static void test_delete(void);
+static void test_get_nthkey(void);
+static void test_get_valuelen(void);
+static void test_get_nkeys(void);
+static void test_get_bool(void);
+static void test_dup(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi_info_t");
+
+    opal_init_util(&argc, &argv);
+    int rc = ompi_mpiinfo_init();
+    test_verify("ompi_mpiinfo_init returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+
+    test_set_and_get();
+    test_get_missing_key();
+    test_overwrite();
+    test_delete();
+    test_get_nthkey();
+    test_get_valuelen();
+    test_get_nkeys();
+    test_get_bool();
+    test_dup();
+
+    /* Note: deliberately do NOT call ompi_mpiinfo_finalize() here.  This is
+     * a partial-init test (no MPI_Init), and finalize assumes full-init
+     * state, so calling it directly segfaults.  The handle-table teardown
+     * path (via the registered ompi_mpi_instance_append_finalize callback)
+     * is exercised by the full-init companion test info_mpi.c at
+     * MPI_Finalize. */
+    int r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_set_and_get(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+    test_verify("OBJ_NEW(ompi_info_t) succeeds", NULL != info);
+
+    int rc = ompi_info_set(info, "mykey", "myvalue");
+    test_verify("set returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    rc = ompi_info_get(info, "mykey", &val, &flag);
+    test_verify("get returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+    test_verify("flag is 1 for existing key", 1 == flag);
+    test_verify("value string matches",
+                NULL != val && 0 == strcmp(val->string, "myvalue"));
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_missing_key(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+
+    opal_cstring_t *val = NULL;
+    int flag = 42; /* sentinel */
+    int rc = ompi_info_get(info, "nosuchkey", &val, &flag);
+    test_verify("get on missing key returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+    test_verify("flag is 0 for missing key", 0 == flag);
+    test_verify("val not modified when flag==0", NULL == val);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_overwrite(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+
+    ompi_info_set(info, "key", "first");
+    int rc = ompi_info_set(info, "key", "second");
+    test_verify("overwrite returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    ompi_info_get(info, "key", &val, &flag);
+    test_verify("value reflects new content after overwrite",
+                NULL != val && 0 == strcmp(val->string, "second"));
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    int nkeys = -1;
+    ompi_info_get_nkeys(info, &nkeys);
+    test_verify("only one entry after overwrite", 1 == nkeys);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_delete(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+
+    ompi_info_set(info, "a", "1");
+    ompi_info_set(info, "b", "2");
+
+    int rc = ompi_info_delete(info, "a");
+    test_verify("delete existing key returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    ompi_info_get(info, "a", &val, &flag);
+    test_verify("deleted key is not found", 0 == flag);
+
+    flag = 0;
+    ompi_info_get(info, "b", &val, &flag);
+    test_verify("remaining key still accessible after delete", 1 == flag);
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    rc = ompi_info_delete(info, "nosuchkey");
+    test_verify("delete missing key returns OMPI_ERR_NOT_FOUND",
+                OMPI_ERR_NOT_FOUND == rc);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_nthkey(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+
+    ompi_info_set(info, "alpha", "1");
+    ompi_info_set(info, "beta",  "2");
+    ompi_info_set(info, "gamma", "3");
+
+    const char *expected[] = {"alpha", "beta", "gamma"};
+    for (int i = 0; i < 3; ++i) {
+        opal_cstring_t *key = NULL;
+        int rc = ompi_info_get_nthkey(info, i, &key);
+        test_verify("get_nthkey returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+        test_verify("nth key matches insertion order",
+                    NULL != key && 0 == strcmp(key->string, expected[i]));
+        if (NULL != key) {
+            OBJ_RELEASE(key);
+        }
+    }
+
+    opal_cstring_t *keyX = NULL;
+    int rc = ompi_info_get_nthkey(info, 3, &keyX);
+    test_verify("get_nthkey(out of range) returns OMPI_ERR_BAD_PARAM",
+                OMPI_ERR_BAD_PARAM == rc);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_valuelen(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+
+    const char *v = "hello";
+    ompi_info_set(info, "k", v);
+
+    int vlen = 0;
+    int flag = 0;
+    int rc = ompi_info_get_valuelen(info, "k", &vlen, &flag);
+    test_verify("get_valuelen returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+    test_verify("flag is 1 for existing key", 1 == flag);
+    test_verify("valuelen equals strlen(value)", (int) strlen(v) == vlen);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_nkeys(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+
+    int nkeys = -1;
+    ompi_info_get_nkeys(info, &nkeys);
+    test_verify("nkeys of fresh info is 0", 0 == nkeys);
+
+    ompi_info_set(info, "x", "1");
+    ompi_info_set(info, "y", "2");
+    ompi_info_get_nkeys(info, &nkeys);
+    test_verify("nkeys is 2 after two sets", 2 == nkeys);
+
+    ompi_info_delete(info, "x");
+    ompi_info_get_nkeys(info, &nkeys);
+    test_verify("nkeys is 1 after a delete", 1 == nkeys);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_bool(void)
+{
+    ompi_info_t *info = OBJ_NEW(ompi_info_t);
+
+    ompi_info_set(info, "btrue", "true");
+    bool bval = false;
+    int flag = 0;
+    int rc = ompi_info_get_bool(info, "btrue", &bval, &flag);
+    test_verify("get_bool(\"true\") returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+    test_verify("flag is 1 for \"true\"", 1 == flag);
+    test_verify("\"true\" parses as true", true == bval);
+
+    ompi_info_set(info, "bfalse", "false");
+    bval = true;
+    flag = 0;
+    ompi_info_get_bool(info, "bfalse", &bval, &flag);
+    test_verify("\"false\" parses as false", false == bval);
+
+    ompi_info_set(info, "bone", "1");
+    bval = false;
+    flag = 0;
+    ompi_info_get_bool(info, "bone", &bval, &flag);
+    test_verify("\"1\" parses as true", true == bval);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_dup(void)
+{
+    ompi_info_t *src = OBJ_NEW(ompi_info_t);
+    ompi_info_set(src, "dk1", "dv1");
+    ompi_info_set(src, "dk2", "dv2");
+
+    /* MPI_Info_dup pre-allocates the destination (via ompi_info_allocate)
+     * before calling ompi_info_dup(); opal_info_dup_impl() appends into the
+     * caller-provided object rather than creating one.  Mirror that
+     * contract here with a fresh OBJ_NEW. */
+    ompi_info_t *dst = OBJ_NEW(ompi_info_t);
+    int rc = ompi_info_dup(src, &dst);
+    test_verify("dup returns OMPI_SUCCESS", OMPI_SUCCESS == rc);
+    test_verify("dup produced a new object", NULL != dst && dst != src);
+
+    int nkeys = -1;
+    ompi_info_get_nkeys(dst, &nkeys);
+    test_verify("dup copied all keys", 2 == nkeys);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    ompi_info_get(dst, "dk1", &val, &flag);
+    test_verify("dup copied values",
+                1 == flag && NULL != val && 0 == strcmp(val->string, "dv1"));
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    OBJ_RELEASE(src);
+    OBJ_RELEASE(dst);
+}
diff --git a/ompi/test/general/info_mpi.c b/ompi/test/general/info_mpi.c
new file mode 100644
index 00000000000..bf7dd87db05
--- /dev/null
+++ b/ompi/test/general/info_mpi.c
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Full-init companion to info_t.c.  Exercises the parts of ompi/info that
+ * need a real runtime: ompi_info_allocate/free (via the MPI_Info API),
+ * the MPI_INFO_ENV object and MPI_Info_create_env (ompi_mpiinfo_init_env),
+ * and the memory-allocation-kinds parser in info_memkind.c
+ * (ompi_info_memkind_process).
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "support.h"
+
+#include "ompi/constants.h"
+#include "ompi/info/info_memkind.h"
+
+#include "mpi.h"
+
+static int argc_saved;
+static char **argv_saved;
+
+static void test_info_api(void);
+static void test_info_env(void);
+static void test_memkind_process(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi info (full init)");
+
+    argc_saved = argc;
+    argv_saved = argv;
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_info_api();
+    test_info_env();
+    test_memkind_process();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+/* Drives ompi_info_allocate/ompi_info_free through the MPI_Info API. */
+static void test_info_api(void)
+{
+    MPI_Info info = MPI_INFO_NULL;
+    int rc = MPI_Info_create(&info);
+    test_verify("Info_create succeeds", MPI_SUCCESS == rc && MPI_INFO_NULL != info);
+
+    MPI_Info_set(info, "key1", "val1");
+    MPI_Info_set(info, "key2", "val2");
+
+    int nkeys = -1;
+    MPI_Info_get_nkeys(info, &nkeys);
+    test_verify("two keys after two sets", 2 == nkeys);
+
+    char key[MPI_MAX_INFO_KEY];
+    rc = MPI_Info_get_nthkey(info, 0, key);
+    test_verify("get_nthkey(0) succeeds", MPI_SUCCESS == rc);
+    test_verify("0th key is key1", 0 == strcmp(key, "key1"));
+
+    int vlen = -1, flag = 0;
+    rc = MPI_Info_get_valuelen(info, "key1", &vlen, &flag);
+    test_verify("get_valuelen finds key1", MPI_SUCCESS == rc && 1 == flag);
+    test_verify("valuelen of val1 is 4", 4 == vlen);
+
+    MPI_Info dup = MPI_INFO_NULL;
+    rc = MPI_Info_dup(info, &dup);
+    test_verify("Info_dup succeeds", MPI_SUCCESS == rc && MPI_INFO_NULL != dup);
+    nkeys = -1;
+    MPI_Info_get_nkeys(dup, &nkeys);
+    test_verify("dup has the same key count", 2 == nkeys);
+
+    rc = MPI_Info_delete(info, "key1");
+    test_verify("Info_delete succeeds", MPI_SUCCESS == rc);
+    MPI_Info_get_nkeys(info, &nkeys);
+    test_verify("one key after delete", 1 == nkeys);
+
+    rc = MPI_Info_free(&info);
+    test_verify("Info_free succeeds", MPI_SUCCESS == rc);
+    test_verify("Info_free NULLs the handle", MPI_INFO_NULL == info);
+    MPI_Info_free(&dup);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_info_env(void)
+{
+    test_verify("MPI_INFO_ENV is not MPI_INFO_NULL", MPI_INFO_NULL != MPI_INFO_ENV);
+
+    int nkeys = -1;
+    MPI_Info_get_nkeys(MPI_INFO_ENV, &nkeys);
+    test_verify("MPI_INFO_ENV has keys", nkeys > 0);
+
+    int flag = 0;
+    char value[MPI_MAX_INFO_VAL];
+    int rc = MPI_Info_get(MPI_INFO_ENV, "maxprocs", MPI_MAX_INFO_VAL - 1, value, &flag);
+    test_verify("MPI_INFO_ENV get(maxprocs) succeeds", MPI_SUCCESS == rc);
+    test_verify("MPI_INFO_ENV has maxprocs", 1 == flag);
+
+    /* MPI_Info_create_env populates a fresh env info (ompi_mpiinfo_init_env) */
+    MPI_Info env = MPI_INFO_NULL;
+    rc = MPI_Info_create_env(argc_saved, argv_saved, &env);
+    test_verify("Info_create_env succeeds", MPI_SUCCESS == rc && MPI_INFO_NULL != env);
+    if (MPI_INFO_NULL != env) {
+        int n = -1;
+        MPI_Info_get_nkeys(env, &n);
+        test_verify("create_env produced keys", n > 0);
+        MPI_Info_free(&env);
+    }
+}
+
+/* ------------------------------------------------------------------ */
+
+/* "system" and "mpi" are always reported as supported (MPI 4.1 12.4.3),
+ * so the provided string must always contain them. */
+static void check_has(const char *what, const char *haystack, const char *needle)
+{
+    test_verify(what, NULL != haystack && NULL != strstr(haystack, needle));
+}
+
+static void test_memkind_process(void)
+{
+    char *provided = NULL;
+    ompi_info_memkind_assert_type type = OMPI_INFO_MEMKIND_ASSERT_UNDEFINED;
+
+    /* NULL request -> NULL provided, UNDEFINED */
+    int rc = ompi_info_memkind_process(NULL, &provided, &type);
+    test_verify("memkind_process(NULL) succeeds", OMPI_SUCCESS == rc);
+    test_verify("memkind_process(NULL) -> NULL provided", NULL == provided);
+    test_verify("memkind_process(NULL) -> UNDEFINED", OMPI_INFO_MEMKIND_ASSERT_UNDEFINED == type);
+
+    /* "system" -> provided contains system and mpi; NO_ACCEL */
+    provided = NULL;
+    rc = ompi_info_memkind_process("system", &provided, &type);
+    test_verify("memkind_process(system) succeeds", OMPI_SUCCESS == rc);
+    check_has("provided contains system", provided, "system");
+    check_has("provided always contains mpi", provided, "mpi");
+    test_verify("system-only is NO_ACCEL", OMPI_INFO_MEMKIND_ASSERT_NO_ACCEL == type);
+    free(provided);
+
+    /* "mpi" with a recognized restrictor */
+    provided = NULL;
+    rc = ompi_info_memkind_process("mpi:alloc_mem", &provided, &type);
+    test_verify("memkind_process(mpi:alloc_mem) succeeds", OMPI_SUCCESS == rc);
+    check_has("provided contains system (added)", provided, "system");
+    check_has("provided contains mpi", provided, "mpi");
+    free(provided);
+
+    /* unsupported kind is dropped, but system+mpi remain */
+    provided = NULL;
+    rc = ompi_info_memkind_process("boguskind", &provided, &type);
+    test_verify("memkind_process(bogus) succeeds", OMPI_SUCCESS == rc);
+    check_has("bogus dropped but system remains", provided, "system");
+    check_has("bogus dropped but mpi remains", provided, "mpi");
+    test_verify("provided does not contain bogus",
+                NULL != provided && NULL == strstr(provided, "bogus"));
+    free(provided);
+}
diff --git a/ompi/test/general/instance.c b/ompi/test/general/instance.c
new file mode 100644
index 00000000000..2cf7452805a
--- /dev/null
+++ b/ompi/test/general/instance.c
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/instance layer (instance.c) via the MPI Sessions
+ * API, which is fully exercisable single-process: session init/finalize,
+ * process-set queries, group-from-pset, communicator-from-group, and
+ * session error handlers.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <string.h>
+
+#include "support.h"
+
+#include "mpi.h"
+
+static int session_eh_calls = 0;
+
+static void session_errhandler(MPI_Session *session, int *code, ...)
+{
+    (void) session; (void) code;
+    ++session_eh_calls;
+}
+
+static void test_session_lifecycle(void);
+static void test_psets(void);
+static void test_group_and_comm(void);
+static void test_session_errhandler(void);
+
+int main(int argc, char *argv[])
+{
+    (void) argc; (void) argv;
+    test_init("ompi instance (sessions)");
+
+    test_session_lifecycle();
+    test_psets();
+    test_group_and_comm();
+    test_session_errhandler();
+
+    return test_finalize();
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_session_lifecycle(void)
+{
+    MPI_Session session = MPI_SESSION_NULL;
+    int rc = MPI_Session_init(MPI_INFO_NULL, MPI_ERRORS_RETURN, &session);
+    test_verify("Session_init succeeds", MPI_SUCCESS == rc);
+    test_verify("session is not NULL", MPI_SESSION_NULL != session);
+
+    MPI_Info info = MPI_INFO_NULL;
+    rc = MPI_Session_get_info(session, &info);
+    test_verify("Session_get_info succeeds", MPI_SUCCESS == rc && MPI_INFO_NULL != info);
+    if (MPI_INFO_NULL != info) {
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_Session_finalize(&session);
+    test_verify("Session_finalize succeeds", MPI_SUCCESS == rc);
+    test_verify("Session_finalize NULLs the handle", MPI_SESSION_NULL == session);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_psets(void)
+{
+    MPI_Session session = MPI_SESSION_NULL;
+    MPI_Session_init(MPI_INFO_NULL, MPI_ERRORS_RETURN, &session);
+
+    int npsets = -1;
+    int rc = MPI_Session_get_num_psets(session, MPI_INFO_NULL, &npsets);
+    test_verify("Session_get_num_psets succeeds", MPI_SUCCESS == rc);
+    test_verify("at least the two predefined psets exist", npsets >= 2);
+
+    bool found_world = false, found_self = false;
+    for (int i = 0; i < npsets; ++i) {
+        char name[MPI_MAX_PSET_NAME_LEN];
+        /* pset_len is INOUT: input is the buffer capacity. */
+        int len = (int) sizeof(name);
+        rc = MPI_Session_get_nth_pset(session, MPI_INFO_NULL, i, &len, name);
+        test_verify("Session_get_nth_pset succeeds", MPI_SUCCESS == rc);
+        if (0 == strcmp(name, "mpi://WORLD")) {
+            found_world = true;
+        }
+        if (0 == strcmp(name, "mpi://SELF")) {
+            found_self = true;
+        }
+    }
+    test_verify("mpi://WORLD pset is present", found_world);
+    test_verify("mpi://SELF pset is present", found_self);
+
+    MPI_Info pinfo = MPI_INFO_NULL;
+    rc = MPI_Session_get_pset_info(session, "mpi://SELF", &pinfo);
+    test_verify("Session_get_pset_info succeeds", MPI_SUCCESS == rc && MPI_INFO_NULL != pinfo);
+    if (MPI_INFO_NULL != pinfo) {
+        /* mpi_size is a required key on a pset info */
+        int flag = 0;
+        char val[MPI_MAX_INFO_VAL];
+        MPI_Info_get(pinfo, "mpi_size", MPI_MAX_INFO_VAL - 1, val, &flag);
+        test_verify("pset info has mpi_size", 1 == flag);
+        MPI_Info_free(&pinfo);
+    }
+
+    MPI_Session_finalize(&session);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_group_and_comm(void)
+{
+    MPI_Session session = MPI_SESSION_NULL;
+    MPI_Session_init(MPI_INFO_NULL, MPI_ERRORS_RETURN, &session);
+
+    MPI_Group group = MPI_GROUP_NULL;
+    int rc = MPI_Group_from_session_pset(session, "mpi://SELF", &group);
+    test_verify("Group_from_session_pset succeeds", MPI_SUCCESS == rc);
+    test_verify("pset group is not NULL", MPI_GROUP_NULL != group);
+
+    int gsize = -1;
+    MPI_Group_size(group, &gsize);
+    test_verify("mpi://SELF group has size 1", 1 == gsize);
+
+    /* NOTE (np>1): MPI_Comm_create_from_group() performs a runtime
+     * (PMIx-server-backed) CID allocation over the pset and fails with
+     * "PMIx server unreachable" in a launcher-less singleton.  It is
+     * therefore deferred to the np>1 effort and not asserted here. */
+
+    MPI_Group_free(&group);
+    MPI_Session_finalize(&session);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_session_errhandler(void)
+{
+    MPI_Session session = MPI_SESSION_NULL;
+    MPI_Session_init(MPI_INFO_NULL, MPI_ERRORS_RETURN, &session);
+
+    MPI_Errhandler eh = MPI_ERRHANDLER_NULL;
+    int rc = MPI_Session_create_errhandler(session_errhandler, &eh);
+    test_verify("Session_create_errhandler succeeds", MPI_SUCCESS == rc);
+
+    rc = MPI_Session_set_errhandler(session, eh);
+    test_verify("Session_set_errhandler succeeds", MPI_SUCCESS == rc);
+
+    MPI_Errhandler got = MPI_ERRHANDLER_NULL;
+    rc = MPI_Session_get_errhandler(session, &got);
+    test_verify("Session_get_errhandler succeeds", MPI_SUCCESS == rc && got == eh);
+    if (MPI_ERRHANDLER_NULL != got) {
+        MPI_Errhandler_free(&got);
+    }
+
+    session_eh_calls = 0;
+    rc = MPI_Session_call_errhandler(session, MPI_ERR_OTHER);
+    test_verify("Session_call_errhandler succeeds", MPI_SUCCESS == rc);
+    test_verify("session errhandler was invoked", 1 == session_eh_calls);
+
+    MPI_Errhandler_free(&eh);
+    MPI_Session_finalize(&session);
+}
diff --git a/ompi/test/general/message.c b/ompi/test/general/message.c
new file mode 100644
index 00000000000..0ef791c12e7
--- /dev/null
+++ b/ompi/test/general/message.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/message layer (message.c): the MPI_Message
+ * object produced by matched probe and consumed by matched receive.
+ * Driven single-process by a self-send on MPI_COMM_SELF plus the
+ * MPI_MESSAGE_NO_PROC special case.  (Matched probe/recv against other
+ * ranks belongs to the np>1 effort.)
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include "support.h"
+
+#include "mpi.h"
+
+static void test_no_pending(void);
+static void test_self_matched(void);
+static void test_no_proc(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi message");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_no_pending();
+    test_self_matched();
+    test_no_proc();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_no_pending(void)
+{
+    int flag = 1;
+    MPI_Message msg = (MPI_Message) 0xdead;
+    MPI_Status status;
+    int rc = MPI_Improbe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_SELF,
+                         &flag, &msg, &status);
+    test_verify("Improbe with nothing pending succeeds", MPI_SUCCESS == rc);
+    test_verify("Improbe reports no match", 0 == flag);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_self_matched(void)
+{
+    int sbuf = 42;
+    MPI_Request sreq = MPI_REQUEST_NULL;
+    int rc = MPI_Isend(&sbuf, 1, MPI_INT, 0, 7, MPI_COMM_SELF, &sreq);
+    test_verify("self Isend succeeds", MPI_SUCCESS == rc);
+
+    /* Bounded nonblocking matched probe drives progress without risking a
+     * hang. */
+    int flag = 0;
+    MPI_Message msg = MPI_MESSAGE_NULL;
+    MPI_Status status;
+    for (int i = 0; i < 1000000 && !flag; ++i) {
+        MPI_Improbe(0, 7, MPI_COMM_SELF, &flag, &msg, &status);
+    }
+    test_verify("Improbe matched the self-send", 1 == flag);
+    test_verify("matched message is not MPI_MESSAGE_NULL", MPI_MESSAGE_NULL != msg);
+
+    /* If the probe never matched (it always should for a COMM_SELF
+     * self-send), the failure is already recorded above.  Bail out rather
+     * than calling Mrecv with MPI_MESSAGE_NULL, which the default fatal
+     * error handler would turn into a process abort that hides the real
+     * failure. */
+    if (!flag) {
+        return;
+    }
+
+    int rbuf = -1;
+    rc = MPI_Mrecv(&rbuf, 1, MPI_INT, &msg, &status);
+    test_verify("Mrecv succeeds", MPI_SUCCESS == rc);
+    test_verify("Mrecv received the sent value", 42 == rbuf);
+    test_verify("Mrecv NULLs the message handle", MPI_MESSAGE_NULL == msg);
+
+    MPI_Wait(&sreq, MPI_STATUS_IGNORE);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_no_proc(void)
+{
+    /* Matched receive from MPI_MESSAGE_NO_PROC is an empty receive. */
+    MPI_Message msg = MPI_MESSAGE_NO_PROC;
+    MPI_Status status;
+    int rc = MPI_Mrecv(NULL, 0, MPI_INT, &msg, &status);
+    test_verify("Mrecv(MPI_MESSAGE_NO_PROC) succeeds", MPI_SUCCESS == rc);
+    test_verify("MESSAGE_NO_PROC source is MPI_PROC_NULL", MPI_PROC_NULL == status.MPI_SOURCE);
+
+    int count = -1;
+    MPI_Get_count(&status, MPI_INT, &count);
+    test_verify("MESSAGE_NO_PROC receive count is 0", 0 == count);
+}
diff --git a/ompi/test/general/mpi_init.c b/ompi/test/general/mpi_init.c
new file mode 100644
index 00000000000..74af4a9fc19
--- /dev/null
+++ b/ompi/test/general/mpi_init.c
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for a full singleton MPI_Init / MPI_Finalize cycle (no
+ * launcher), which works under "make check" because Open MPI supports
+ * singleton startup.  This exercises the basic runtime/instance bring-up
+ * and teardown plus trivial MPI_COMM_WORLD / MPI_COMM_SELF queries.  It
+ * also establishes that "full init" tests are viable for covering the
+ * runtime-dependent ompi/ directories that partial init cannot reach.
+ */
+
+#include "ompi_config.h"
+
+#include "support.h"
+
+#include "mpi.h"
+
+int main(int argc, char *argv[])
+{
+    test_init("MPI singleton init");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init returns MPI_SUCCESS", MPI_SUCCESS == rc);
+
+    int rank = -1, size = -1;
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+    MPI_Comm_size(MPI_COMM_WORLD, &size);
+    test_verify("singleton MPI_COMM_WORLD rank is 0", 0 == rank);
+    test_verify("singleton MPI_COMM_WORLD size is 1", 1 == size);
+
+    int self_size = -1;
+    MPI_Comm_size(MPI_COMM_SELF, &self_size);
+    test_verify("MPI_COMM_SELF size is 1", 1 == self_size);
+
+    rc = MPI_Finalize();
+    test_verify("MPI_Finalize returns MPI_SUCCESS", MPI_SUCCESS == rc);
+
+    return test_finalize();
+}
diff --git a/ompi/test/general/op.c b/ompi/test/general/op.c
new file mode 100644
index 00000000000..d704292ef3c
--- /dev/null
+++ b/ompi/test/general/op.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/op layer (op.c).  ompi_op_init() (which builds
+ * the datatype->op map and all 15 intrinsic ops) runs during MPI_Init,
+ * so a full singleton init plus the public MPI_Op API exercises the
+ * bulk of op.c, including user-op creation (ompi_op_create_user) and the
+ * reduction dispatch (MPI_Reduce_local).
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include "support.h"
+
+#include "mpi.h"
+
+static void test_predefined_commutative(void);
+static void test_reduce_local_intrinsic(void);
+static void test_user_op(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi op");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_predefined_commutative();
+    test_reduce_local_intrinsic();
+    test_user_op();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_predefined_commutative(void)
+{
+    int flag = -1;
+    MPI_Op_commutative(MPI_SUM, &flag);
+    test_verify("MPI_SUM is commutative", 1 == flag);
+
+    flag = -1;
+    MPI_Op_commutative(MPI_MAX, &flag);
+    test_verify("MPI_MAX is commutative", 1 == flag);
+
+    flag = -1;
+    MPI_Op_commutative(MPI_PROD, &flag);
+    test_verify("MPI_PROD is commutative", 1 == flag);
+
+    /* MPI_REPLACE and MPI_NO_OP exist and are usable handles */
+    test_verify("MPI_REPLACE handle is non-NULL", MPI_OP_NULL != MPI_REPLACE);
+    test_verify("MPI_NO_OP handle is non-NULL", MPI_OP_NULL != MPI_NO_OP);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_reduce_local_intrinsic(void)
+{
+    /* MPI_SUM */
+    int in = 2, inout = 3;
+    int rc = MPI_Reduce_local(&in, &inout, 1, MPI_INT, MPI_SUM);
+    test_verify("Reduce_local MPI_SUM succeeds", MPI_SUCCESS == rc);
+    test_verify("MPI_SUM: 2 + 3 == 5", 5 == inout);
+
+    /* MPI_MAX */
+    in = 2; inout = 3;
+    MPI_Reduce_local(&in, &inout, 1, MPI_INT, MPI_MAX);
+    test_verify("MPI_MAX: max(2,3) == 3", 3 == inout);
+    in = 5; inout = 3;
+    MPI_Reduce_local(&in, &inout, 1, MPI_INT, MPI_MAX);
+    test_verify("MPI_MAX: max(5,3) == 5", 5 == inout);
+
+    /* MPI_PROD over multiple elements */
+    int va[3] = {1, 2, 3};
+    int vb[3] = {4, 5, 6};
+    MPI_Reduce_local(va, vb, 3, MPI_INT, MPI_PROD);
+    test_verify("MPI_PROD elementwise", 4 == vb[0] && 10 == vb[1] && 18 == vb[2]);
+
+    /* MPI_LAND on logical-ish ints */
+    int la = 1, lb = 0;
+    MPI_Reduce_local(&la, &lb, 1, MPI_INT, MPI_LAND);
+    test_verify("MPI_LAND: 1 && 0 == 0", 0 == lb);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void user_sum(void *invec, void *inoutvec, int *len, MPI_Datatype *dt)
+{
+    (void) dt;
+    int *in = (int *) invec;
+    int *inout = (int *) inoutvec;
+    for (int i = 0; i < *len; ++i) {
+        inout[i] += in[i];
+    }
+}
+
+static void test_user_op(void)
+{
+    /* commutative user op */
+    MPI_Op op = MPI_OP_NULL;
+    int rc = MPI_Op_create(user_sum, 1, &op);
+    test_verify("Op_create (commutative) succeeds", MPI_SUCCESS == rc);
+    test_verify("created op is non-NULL", MPI_OP_NULL != op);
+
+    int flag = -1;
+    MPI_Op_commutative(op, &flag);
+    test_verify("user op reports commutative", 1 == flag);
+
+    int in = 7, inout = 10;
+    MPI_Reduce_local(&in, &inout, 1, MPI_INT, op);
+    test_verify("user op reduce: 7 + 10 == 17", 17 == inout);
+
+    rc = MPI_Op_free(&op);
+    test_verify("Op_free succeeds", MPI_SUCCESS == rc);
+    test_verify("Op_free sets handle to MPI_OP_NULL", MPI_OP_NULL == op);
+
+    /* non-commutative user op */
+    MPI_Op op2 = MPI_OP_NULL;
+    MPI_Op_create(user_sum, 0, &op2);
+    flag = -1;
+    MPI_Op_commutative(op2, &flag);
+    test_verify("non-commutative user op reports non-commutative", 0 == flag);
+    MPI_Op_free(&op2);
+}
diff --git a/ompi/test/general/proc.c b/ompi/test/general/proc.c
new file mode 100644
index 00000000000..e19e77441cf
--- /dev/null
+++ b/ompi/test/general/proc.c
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/proc layer (proc.c).  The proc subsystem is
+ * entirely runtime-dependent (it is populated from the PMIx modex during
+ * MPI_Init), so this test uses a full singleton MPI_Init and then calls
+ * the internal ompi_proc_* accessors directly.
+ *
+ * Memory semantics (see proc.h):
+ *   - ompi_proc_world()/get_allocated(): proc refcounts NOT incremented;
+ *     caller frees only the returned array.
+ *   - ompi_proc_self()/all(): proc refcounts incremented; caller must
+ *     OBJ_RELEASE each entry and free the array.
+ *   - ompi_proc_local()/find(): no refcount change.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <stdlib.h>
+
+#include "support.h"
+
+#include "opal/class/opal_object.h"
+
+#include "ompi/constants.h"
+#include "ompi/proc/proc.h"
+
+#include "mpi.h"
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi proc");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    ompi_proc_t *local = ompi_proc_local();
+    test_verify("ompi_proc_local() is non-NULL", NULL != local);
+
+    test_verify("ompi_proc_world_size() is 1 (singleton)", 1 == ompi_proc_world_size());
+
+    /* world: array owned by caller, procs not retained */
+    size_t sz = 0;
+    ompi_proc_t **world = ompi_proc_world(&sz);
+    test_verify("ompi_proc_world() returns a list", NULL != world);
+    test_verify("world size is 1", 1 == sz);
+    test_verify("world[0] is the local proc", NULL != world && world[0] == local);
+    free(world);
+
+    /* allocated: array owned by caller, procs not retained */
+    sz = 0;
+    ompi_proc_t **alloc = ompi_proc_get_allocated(&sz);
+    test_verify("ompi_proc_get_allocated() returns a list", NULL != alloc);
+    test_verify("allocated size is >= 1", sz >= 1);
+    free(alloc);
+
+    /* self: procs retained, caller releases */
+    sz = 0;
+    ompi_proc_t **self = ompi_proc_self(&sz);
+    test_verify("ompi_proc_self() returns a list", NULL != self);
+    test_verify("self size is 1", 1 == sz);
+    test_verify("self[0] is the local proc", NULL != self && self[0] == local);
+    if (NULL != self) {
+        for (size_t i = 0; i < sz; ++i) {
+            OBJ_RELEASE(self[i]);
+        }
+        free(self);
+    }
+
+    /* all: procs retained, caller releases */
+    sz = 0;
+    ompi_proc_t **all = ompi_proc_all(&sz);
+    test_verify("ompi_proc_all() returns a list", NULL != all);
+    test_verify("all size is 1 (singleton)", 1 == sz);
+    if (NULL != all) {
+        for (size_t i = 0; i < sz; ++i) {
+            OBJ_RELEASE(all[i]);
+        }
+        free(all);
+    }
+
+    /* find by name returns the local proc */
+    if (NULL != local) {
+        ompi_proc_t *found = (ompi_proc_t *) ompi_proc_find(&local->super.proc_name);
+        test_verify("ompi_proc_find() locates the local proc by name", found == local);
+    }
+
+    rc = ompi_proc_refresh();
+    test_verify("ompi_proc_refresh() succeeds", OMPI_SUCCESS == rc);
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
diff --git a/ompi/test/general/request.c b/ompi/test/general/request.c
new file mode 100644
index 00000000000..7e86ab0ae36
--- /dev/null
+++ b/ompi/test/general/request.c
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/request layer (request.c, grequest.c,
+ * req_wait.c, req_test.c).  Generalized requests are fully exercisable
+ * single-process, and the wait/test family is driven over arrays mixing
+ * MPI_REQUEST_NULL with a completed generalized request.  (Point-to-point
+ * request progress between ranks is out of scope for single-process and
+ * belongs to the np>1 effort.)
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include "support.h"
+
+#include "mpi.h"
+
+static int query_calls = 0;
+static int free_calls = 0;
+static int cancel_calls = 0;
+
+static int grequest_query(void *extra, MPI_Status *status)
+{
+    (void) extra;
+    ++query_calls;
+    MPI_Status_set_elements(status, MPI_INT, 1);
+    MPI_Status_set_cancelled(status, 0);
+    status->MPI_SOURCE = MPI_ANY_SOURCE;
+    status->MPI_TAG = MPI_ANY_TAG;
+    return MPI_SUCCESS;
+}
+
+static int grequest_free(void *extra)
+{
+    (void) extra;
+    ++free_calls;
+    return MPI_SUCCESS;
+}
+
+static int grequest_cancel(void *extra, int complete)
+{
+    (void) extra; (void) complete;
+    ++cancel_calls;
+    return MPI_SUCCESS;
+}
+
+static void test_null_requests(void);
+static void test_grequest_wait(void);
+static void test_grequest_test(void);
+static void test_array_ops(void);
+static void test_cancel(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi request");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_null_requests();
+    test_grequest_wait();
+    test_grequest_test();
+    test_array_ops();
+    test_cancel();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_null_requests(void)
+{
+    MPI_Request req = MPI_REQUEST_NULL;
+    MPI_Status status;
+    int rc = MPI_Wait(&req, &status);
+    test_verify("Wait on MPI_REQUEST_NULL succeeds", MPI_SUCCESS == rc);
+
+    req = MPI_REQUEST_NULL;
+    int flag = 0;
+    rc = MPI_Test(&req, &flag, &status);
+    test_verify("Test on MPI_REQUEST_NULL succeeds", MPI_SUCCESS == rc);
+    test_verify("Test on MPI_REQUEST_NULL sets flag", 1 == flag);
+
+    req = MPI_REQUEST_NULL;
+    flag = 0;
+    rc = MPI_Request_get_status(req, &flag, &status);
+    test_verify("Request_get_status(NULL) succeeds", MPI_SUCCESS == rc && 1 == flag);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_grequest_wait(void)
+{
+    query_calls = free_calls = 0;
+    MPI_Request req = MPI_REQUEST_NULL;
+    int rc = MPI_Grequest_start(grequest_query, grequest_free, grequest_cancel,
+                                NULL, &req);
+    test_verify("Grequest_start succeeds", MPI_SUCCESS == rc);
+    test_verify("grequest is not NULL", MPI_REQUEST_NULL != req);
+
+    rc = MPI_Grequest_complete(req);
+    test_verify("Grequest_complete succeeds", MPI_SUCCESS == rc);
+
+    MPI_Status status;
+    rc = MPI_Wait(&req, &status);
+    test_verify("Wait on completed grequest succeeds", MPI_SUCCESS == rc);
+    test_verify("query callback was invoked", 1 == query_calls);
+    test_verify("free callback was invoked", 1 == free_calls);
+    test_verify("Wait NULLed the request handle", MPI_REQUEST_NULL == req);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_grequest_test(void)
+{
+    query_calls = free_calls = 0;
+    MPI_Request req = MPI_REQUEST_NULL;
+    MPI_Grequest_start(grequest_query, grequest_free, grequest_cancel, NULL, &req);
+
+    /* not completed yet: Test must report incomplete */
+    int flag = 1;
+    MPI_Status status;
+    int rc = MPI_Test(&req, &flag, &status);
+    test_verify("Test on incomplete grequest succeeds", MPI_SUCCESS == rc);
+    test_verify("incomplete grequest Test flag is 0", 0 == flag);
+
+    MPI_Grequest_complete(req);
+    flag = 0;
+    rc = MPI_Test(&req, &flag, &status);
+    test_verify("Test on completed grequest succeeds", MPI_SUCCESS == rc);
+    test_verify("completed grequest Test flag is 1", 1 == flag);
+    test_verify("query callback invoked by Test", 1 == query_calls);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_array_ops(void)
+{
+    /* Build an array: [NULL, completed-grequest, NULL] */
+    MPI_Request reqs[3];
+    reqs[0] = MPI_REQUEST_NULL;
+    reqs[2] = MPI_REQUEST_NULL;
+    MPI_Grequest_start(grequest_query, grequest_free, grequest_cancel, NULL, &reqs[1]);
+    MPI_Grequest_complete(reqs[1]);
+
+    MPI_Status statuses[3];
+    int rc = MPI_Waitall(3, reqs, statuses);
+    test_verify("Waitall over mixed array succeeds", MPI_SUCCESS == rc);
+    test_verify("Waitall NULLed the grequest", MPI_REQUEST_NULL == reqs[1]);
+
+    /* Testall on an all-NULL array reports done */
+    reqs[1] = MPI_REQUEST_NULL;
+    int flag = 0;
+    rc = MPI_Testall(3, reqs, &flag, statuses);
+    test_verify("Testall on all-NULL succeeds", MPI_SUCCESS == rc);
+    test_verify("Testall on all-NULL reports complete", 1 == flag);
+
+    /* Waitany on all-NULL returns MPI_UNDEFINED */
+    int index = -2;
+    MPI_Status st;
+    rc = MPI_Waitany(3, reqs, &index, &st);
+    test_verify("Waitany on all-NULL succeeds", MPI_SUCCESS == rc);
+    test_verify("Waitany on all-NULL yields MPI_UNDEFINED", MPI_UNDEFINED == index);
+
+    /* Waitany picks the completed grequest */
+    MPI_Grequest_start(grequest_query, grequest_free, grequest_cancel, NULL, &reqs[1]);
+    MPI_Grequest_complete(reqs[1]);
+    index = -2;
+    rc = MPI_Waitany(3, reqs, &index, &st);
+    test_verify("Waitany finds the completed request", MPI_SUCCESS == rc && 1 == index);
+
+    /* Testsome on all-NULL returns MPI_UNDEFINED outcount */
+    int outcount = -2;
+    int indices[3];
+    rc = MPI_Testsome(3, reqs, &outcount, indices, statuses);
+    test_verify("Testsome on all-NULL succeeds", MPI_SUCCESS == rc);
+    test_verify("Testsome on all-NULL yields MPI_UNDEFINED", MPI_UNDEFINED == outcount);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_cancel(void)
+{
+    cancel_calls = 0;
+    MPI_Request req = MPI_REQUEST_NULL;
+    MPI_Grequest_start(grequest_query, grequest_free, grequest_cancel, NULL, &req);
+
+    int rc = MPI_Cancel(&req);
+    test_verify("Cancel on a grequest succeeds", MPI_SUCCESS == rc);
+    test_verify("cancel callback was invoked", 1 == cancel_calls);
+
+    /* must still be completed and freed to release it */
+    MPI_Grequest_complete(req);
+    MPI_Status status;
+    MPI_Wait(&req, &status);
+
+    int cancelled = -1;
+    MPI_Test_cancelled(&status, &cancelled);
+    test_verify("Test_cancelled is callable on the status", cancelled == 0 || cancelled == 1);
+}
diff --git a/ompi/test/general/seq_tracker.c b/ompi/test/general/seq_tracker.c
new file mode 100644
index 00000000000..d20e7a1adda
--- /dev/null
+++ b/ompi/test/general/seq_tracker.c
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2006 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for ompi_seq_tracker_t (ompi/class/ompi_seq_tracker.c).  The
+ * sequence tracker records which sequence numbers have been "seen",
+ * compacting contiguous runs into a single [low,high] range entry.  This
+ * test exercises insertion (including range extension, bidirectional
+ * consolidation, and gap handling), duplicate detection (including the
+ * forward/backward list navigation), and copy.
+ *
+ * Pure opal-level object: only opal_init_util() is required (the
+ * OBJ_CLASS machinery + opal_list); no MPI/instance bring-up.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <stddef.h>
+
+#include "support.h"
+
+#include "opal/runtime/opal.h"
+#include "opal/class/opal_list.h"
+
+#include "ompi/class/ompi_seq_tracker.h"
+
+/* Count the number of [low,high] range entries currently stored. */
+static size_t n_ranges(ompi_seq_tracker_t *t)
+{
+    return opal_list_get_size(&t->seq_ids);
+}
+
+/* Fetch the nth range entry (in list order), or NULL if out of range. */
+static ompi_seq_tracker_range_t *range_at(ompi_seq_tracker_t *t, size_t n)
+{
+    opal_list_item_t *item;
+    size_t i = 0;
+    for (item = opal_list_get_first(&t->seq_ids);
+         item != opal_list_get_end(&t->seq_ids);
+         item = opal_list_get_next(item), ++i) {
+        if (i == n) {
+            return (ompi_seq_tracker_range_t *) item;
+        }
+    }
+    return NULL;
+}
+
+static void test_empty(void);
+static void test_single(void);
+static void test_duplicate(void);
+static void test_ascending_run(void);
+static void test_descending_run(void);
+static void test_gap_then_fill(void);
+static void test_two_ranges(void);
+static void test_navigation(void);
+static void test_copy(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi_seq_tracker_t");
+
+    opal_init_util(&argc, &argv);
+
+    test_empty();
+    test_single();
+    test_duplicate();
+    test_ascending_run();
+    test_descending_run();
+    test_gap_then_fill();
+    test_two_ranges();
+    test_navigation();
+    test_copy();
+
+    int r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_empty(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+    test_verify("OBJ_NEW(ompi_seq_tracker_t) succeeds", NULL != t);
+    test_verify("fresh tracker has no ranges", 0 == n_ranges(t));
+    test_verify("check_duplicate on empty tracker is false",
+                false == ompi_seq_tracker_check_duplicate(t, 7));
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_single(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+
+    ompi_seq_tracker_insert(t, 5);
+    test_verify("single insert creates one range", 1 == n_ranges(t));
+    ompi_seq_tracker_range_t *r = range_at(t, 0);
+    test_verify("range is [5,5]", NULL != r && 5 == r->seq_id_low && 5 == r->seq_id_high);
+
+    test_verify("inserted id is a duplicate", true == ompi_seq_tracker_check_duplicate(t, 5));
+    test_verify("neighbor below is not present", false == ompi_seq_tracker_check_duplicate(t, 4));
+    test_verify("neighbor above is not present", false == ompi_seq_tracker_check_duplicate(t, 6));
+
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_duplicate(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+
+    ompi_seq_tracker_insert(t, 5);
+    ompi_seq_tracker_insert(t, 5); /* inserting an existing id is a no-op */
+    test_verify("re-inserting an id does not add a range", 1 == n_ranges(t));
+    ompi_seq_tracker_range_t *r = range_at(t, 0);
+    test_verify("range still [5,5] after duplicate insert",
+                NULL != r && 5 == r->seq_id_low && 5 == r->seq_id_high);
+
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_ascending_run(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+
+    for (uint32_t i = 1; i <= 5; ++i) {
+        ompi_seq_tracker_insert(t, i);
+    }
+    /* A contiguous ascending run must compact to a single [1,5] range. */
+    test_verify("ascending run compacts to one range", 1 == n_ranges(t));
+    ompi_seq_tracker_range_t *r = range_at(t, 0);
+    test_verify("compacted range is [1,5]",
+                NULL != r && 1 == r->seq_id_low && 5 == r->seq_id_high);
+
+    for (uint32_t i = 1; i <= 5; ++i) {
+        test_verify("each id in the run is a duplicate",
+                    true == ompi_seq_tracker_check_duplicate(t, i));
+    }
+    test_verify("id past the run is not present", false == ompi_seq_tracker_check_duplicate(t, 6));
+
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_descending_run(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+
+    for (uint32_t i = 5; i >= 1; --i) {
+        ompi_seq_tracker_insert(t, i); /* exercises the seq_id_low-1 path */
+    }
+    test_verify("descending run compacts to one range", 1 == n_ranges(t));
+    ompi_seq_tracker_range_t *r = range_at(t, 0);
+    test_verify("compacted descending range is [1,5]",
+                NULL != r && 1 == r->seq_id_low && 5 == r->seq_id_high);
+
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_gap_then_fill(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+
+    ompi_seq_tracker_insert(t, 1);
+    ompi_seq_tracker_insert(t, 3);
+    test_verify("non-adjacent ids create two ranges", 2 == n_ranges(t));
+    test_verify("the gap id is not present", false == ompi_seq_tracker_check_duplicate(t, 2));
+
+    /* Inserting the gap value must merge the two ranges into one [1,3]. */
+    ompi_seq_tracker_insert(t, 2);
+    test_verify("filling the gap merges into one range", 1 == n_ranges(t));
+    ompi_seq_tracker_range_t *r = range_at(t, 0);
+    test_verify("merged range is [1,3]",
+                NULL != r && 1 == r->seq_id_low && 3 == r->seq_id_high);
+    test_verify("the filled id is now present", true == ompi_seq_tracker_check_duplicate(t, 2));
+
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_two_ranges(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+
+    ompi_seq_tracker_insert(t, 1);
+    ompi_seq_tracker_insert(t, 2);
+    ompi_seq_tracker_insert(t, 10);
+    ompi_seq_tracker_insert(t, 11);
+    test_verify("two disjoint runs yield two ranges", 2 == n_ranges(t));
+
+    test_verify("1 present", true == ompi_seq_tracker_check_duplicate(t, 1));
+    test_verify("2 present", true == ompi_seq_tracker_check_duplicate(t, 2));
+    test_verify("10 present", true == ompi_seq_tracker_check_duplicate(t, 10));
+    test_verify("11 present", true == ompi_seq_tracker_check_duplicate(t, 11));
+    test_verify("5 (between runs) absent", false == ompi_seq_tracker_check_duplicate(t, 5));
+    test_verify("12 (past runs) absent", false == ompi_seq_tracker_check_duplicate(t, 12));
+
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * Build several disjoint ranges and then query ids that force the
+ * duplicate-check scan to walk both forward and backward from the
+ * "current" pointer.
+ */
+static void test_navigation(void)
+{
+    ompi_seq_tracker_t *t = OBJ_NEW(ompi_seq_tracker_t);
+
+    /* ranges: [1,2], [10,11], [20,21] */
+    ompi_seq_tracker_insert(t, 1);
+    ompi_seq_tracker_insert(t, 2);
+    ompi_seq_tracker_insert(t, 10);
+    ompi_seq_tracker_insert(t, 11);
+    ompi_seq_tracker_insert(t, 20);
+    ompi_seq_tracker_insert(t, 21);
+    test_verify("three disjoint runs yield three ranges", 3 == n_ranges(t));
+
+    /* current is near the end after the last insert; query low ids
+       (backward scan) then high ids (forward scan). */
+    test_verify("backward scan finds 1", true == ompi_seq_tracker_check_duplicate(t, 1));
+    test_verify("forward scan finds 21", true == ompi_seq_tracker_check_duplicate(t, 21));
+    test_verify("middle range found", true == ompi_seq_tracker_check_duplicate(t, 10));
+    test_verify("between-range id absent (15)", false == ompi_seq_tracker_check_duplicate(t, 15));
+    test_verify("below-everything id absent (0)", false == ompi_seq_tracker_check_duplicate(t, 0));
+
+    OBJ_RELEASE(t);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_copy(void)
+{
+    ompi_seq_tracker_t *src = OBJ_NEW(ompi_seq_tracker_t);
+    ompi_seq_tracker_insert(src, 1);
+    ompi_seq_tracker_insert(src, 2);
+    ompi_seq_tracker_insert(src, 3);
+    ompi_seq_tracker_insert(src, 10);
+
+    ompi_seq_tracker_t *dst = OBJ_NEW(ompi_seq_tracker_t);
+    ompi_seq_tracker_copy(dst, src);
+
+    test_verify("copy reproduces the same range count",
+                n_ranges(src) == n_ranges(dst));
+    test_verify("copied tracker reports same membership (1)",
+                true == ompi_seq_tracker_check_duplicate(dst, 1));
+    test_verify("copied tracker reports same membership (3)",
+                true == ompi_seq_tracker_check_duplicate(dst, 3));
+    test_verify("copied tracker reports same membership (10)",
+                true == ompi_seq_tracker_check_duplicate(dst, 10));
+    test_verify("copied tracker absent id (5)",
+                false == ompi_seq_tracker_check_duplicate(dst, 5));
+
+    /* dst must be independent: extending dst must not change src. */
+    ompi_seq_tracker_insert(dst, 5);
+    test_verify("inserting into copy does not affect source",
+                false == ompi_seq_tracker_check_duplicate(src, 5));
+
+    OBJ_RELEASE(src);
+    OBJ_RELEASE(dst);
+}
diff --git a/ompi/test/general/support.c b/ompi/test/general/support.c
new file mode 100644
index 00000000000..088db7a659c
--- /dev/null
+++ b/ompi/test/general/support.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2010      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2024      Amazon.com, Inc. or its affiliates.
+ *                         All Rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "ompi_config.h"
+#include <assert.h>
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "support.h"
+
+#define test_verify_number(T, specifier)                                           \
+    int test_verify_##T(T expected_result, T test_result)                          \
+    {                                                                              \
+        int return_value;                                                          \
+        return_value = 1;                                                          \
+        if (expected_result != test_result) {                                      \
+            test_failure("Comparison failure");                                    \
+            fprintf(stderr, " Expected result: " specifier "\n", expected_result); \
+            fprintf(stderr, " Test result: " specifier "\n", test_result);         \
+            fflush(stderr);                                                        \
+            return_value = 0;                                                      \
+        } else {                                                                   \
+            test_success();                                                        \
+        }                                                                          \
+        return return_value;                                                       \
+    }
+
+test_verify_number(int, "%d")
+test_verify_number(int64_t, "%" PRId64)
+test_verify_number(size_t, "%zu")
+test_verify_number(double, "%lf")
+
+/**
+ * A testing support library to provide uniform reporting output
+ */
+
+static int opal_n_tests;
+static int opal_n_success;
+static int opal_n_failures;
+static char *opal_description;
+
+void test_init(const char *a)
+{
+    /* local variables */
+    size_t len;
+
+    /* save the descriptive string.  Do not rely on assert() here: the
+     * tests are compiled with -DNDEBUG, so assert() is a no-op and an
+     * allocation failure would otherwise fall through to a NULL deref in
+     * strcpy(). */
+    len = strlen(a);
+    opal_description = (char *) malloc(len + 1);
+    if (NULL == opal_description) {
+        fprintf(stderr, "test_init: out of memory\n");
+        exit(1);
+    }
+
+    strcpy(opal_description, a);
+
+    /* initialize counters */
+    opal_n_tests = 0;
+    opal_n_success = 0;
+    opal_n_failures = 0;
+
+    return;
+}
+
+void test_success(void)
+{
+    opal_n_tests++;
+    opal_n_success++;
+}
+
+void test_failure(const char *a)
+{
+    opal_n_tests++;
+    opal_n_failures++;
+
+    fprintf(stderr, " Failure : ");
+    fprintf(stderr, "%s", a);
+    fprintf(stderr, "\n");
+    fflush(stderr);
+}
+
+int test_verify_str(const char *expected_result, const char *test_result)
+{
+    size_t len_expect, len_result;
+    int return_value;
+
+    return_value = 1;
+    len_expect = expected_result ? strlen(expected_result) : 0;
+    len_result = test_result ? strlen(test_result) : 0;
+
+    if ((!(len_expect == len_result)) || (0 != strcmp(expected_result, test_result))) {
+        test_failure("Comparison failure");
+        fprintf(stderr, " Expected result: %s\n", expected_result);
+        fprintf(stderr, " Test result: %s\n", test_result);
+        fflush(stderr);
+        return_value = 0;
+    } else {
+        test_success();
+    }
+
+    return return_value;
+}
+
+int test_finalize(void)
+{
+    int return_value;
+
+    return_value = 0;
+
+    if (opal_n_tests == opal_n_success) {
+        fprintf(stderr, "SUPPORT: OMPI Test Passed: %s: (%d tests)\n", opal_description,
+                opal_n_tests);
+        fflush(stderr);
+    } else {
+        fprintf(stderr, "SUPPORT: OMPI Test failed: %s (%d of %d failed)\n", opal_description,
+                opal_n_failures, opal_n_tests);
+        fflush(stderr);
+        return_value = 1;
+    }
+
+    if (NULL != opal_description)
+        free(opal_description);
+
+    return return_value;
+}
+
+/* note this is for additional output that does NOT go to STDERR but STDOUT */
+void test_comment(const char *userstr)
+{
+    fprintf(stdout, "%s:%s\n", opal_description, userstr);
+}
+
+void test_fail_stop(const char *msg, int status)
+{
+    test_failure(msg);
+    test_finalize();
+    exit(status);
+}
diff --git a/ompi/test/general/support.h b/ompi/test/general/support.h
new file mode 100644
index 00000000000..ca3a56f9274
--- /dev/null
+++ b/ompi/test/general/support.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2024      Amazon.com, Inc. or its affiliates.
+ *                         All Rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Self-contained test harness for the OMPI unit tests under ompi/test/.
+ * Deliberately a sibling of test/support/support.h so that the OMPI unit
+ * tests build and run entirely within the ompi/ subtree (e.g. "make check"
+ * run solely inside ompi/) without depending on the top-level test/ tree.
+ * The API is intentionally identical to test/support/support.h.
+ */
+
+#ifndef OMPI_TEST_SUPPORT_H
+#define OMPI_TEST_SUPPORT_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#define TEST_AND_REPORT(res, exp_res, str) \
+    do {                                   \
+        if ((res) == (exp_res)) {          \
+            test_success();                \
+        } else {                           \
+            test_failure(str);             \
+        }                                  \
+    } while (0)
+
+void test_init(const char *a);
+void test_success(void);
+void test_failure(const char *a);
+int test_verify_str(const char *expected_result, const char *test_result);
+int test_verify_int(int expected_result, int test_result);
+int test_verify_int64_t(int64_t expected_result, int64_t test_result);
+int test_verify_size_t(size_t expected_result, size_t test_result);
+int test_verify_double(double expected_result, double test_result);
+int test_finalize(void);
+void test_comment(const char *userstr);
+void test_fail_stop(const char *msg, int status);
+
+/*
+ * test_verify: Non-fatal assertion macro.
+ */
+
+#define test_verify(MESSAGE, EXPR)                                                         \
+    do {                                                                                   \
+        if (!(EXPR)) {                                                                     \
+            char s[256];                                                                   \
+            snprintf(s, sizeof(s), "%s:%d: %s: %s\n", __FILE__, __LINE__, MESSAGE, #EXPR); \
+            test_failure(s);                                                               \
+        } else {                                                                           \
+            test_success();                                                                \
+        }                                                                                  \
+    } while (0)
+
+#endif /* OMPI_TEST_SUPPORT_H */
diff --git a/ompi/test/general/values-f.h b/ompi/test/general/values-f.h
new file mode 100644
index 00000000000..b9be2a61c36
--- /dev/null
+++ b/ompi/test/general/values-f.h
@@ -0,0 +1,23 @@
+! -*- fortran -*-
+!
+! Copyright (c) 2012      Cisco Systems, Inc.  All rights reserved.
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+! $COPYRIGHT$
+!
+! Additional copyrights may follow
+!
+! $HEADER$
+!
+
+! Do not change these values without also changing their corresponding
+! values in attr_interlang.c!
+
+      integer, parameter :: FORTRAN_MPI1_VALUE1 = 771
+      integer, parameter :: FORTRAN_MPI1_VALUE2 = -771
+      integer, parameter :: FORTRAN_MPI1_VALUE3 = -123
+      integer, parameter :: FORTRAN_MPI2_VALUE1 = 772
+      integer, parameter :: FORTRAN_MPI2_VALUE2 = -772
+      integer, parameter :: FORTRAN_MPI2_VALUE3 = -123
+      integer, parameter :: C_VALUE1 = 99
+      integer, parameter :: C_VALUE2 = -99
+      integer, parameter :: C_VALUE3 = 481
diff --git a/ompi/test/general/win.c b/ompi/test/general/win.c
new file mode 100644
index 00000000000..2fdb9f7a167
--- /dev/null
+++ b/ompi/test/general/win.c
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for the ompi/win layer (win.c): the MPI_Win object lifecycle.
+ * All four creation flavors are exercised on MPI_COMM_SELF (single
+ * process), along with the window group, name, info, and predefined
+ * attributes.  Actual RMA data movement and synchronization between ranks
+ * belongs to the np>1 effort.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <string.h>
+
+#include "support.h"
+
+#include "mpi.h"
+
+static void check_window_common(const char *what, MPI_Win win);
+
+static void test_create(void);
+static void test_allocate(void);
+static void test_allocate_shared(void);
+static void test_create_dynamic(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("ompi win");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_create();
+    test_allocate();
+    test_allocate_shared();
+    test_create_dynamic();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+/* Exercise the parts of the window object API that are independent of the
+ * creation flavor. */
+static void check_window_common(const char *what, MPI_Win win)
+{
+    test_verify(what, MPI_WIN_NULL != win);
+    if (MPI_WIN_NULL == win) {
+        return;
+    }
+
+    MPI_Group grp = MPI_GROUP_NULL;
+    int rc = MPI_Win_get_group(win, &grp);
+    test_verify("Win_get_group succeeds", MPI_SUCCESS == rc);
+    int gsize = -1;
+    MPI_Group_size(grp, &gsize);
+    test_verify("window group size is 1", 1 == gsize);
+    MPI_Group_free(&grp);
+
+    rc = MPI_Win_set_name(win, "mywin");
+    test_verify("Win_set_name succeeds", MPI_SUCCESS == rc);
+    char name[MPI_MAX_OBJECT_NAME];
+    int len = -1;
+    rc = MPI_Win_get_name(win, name, &len);
+    test_verify("Win_get_name succeeds", MPI_SUCCESS == rc);
+    test_verify("Win_get_name round-trips",
+                MPI_SUCCESS == rc && 0 == strcmp(name, "mywin"));
+
+    MPI_Info setinfo = MPI_INFO_NULL;
+    MPI_Info_create(&setinfo);
+    MPI_Info_set(setinfo, "no_locks", "false");
+    rc = MPI_Win_set_info(win, setinfo);
+    test_verify("Win_set_info succeeds", MPI_SUCCESS == rc);
+    MPI_Info_free(&setinfo);
+
+    MPI_Info gotinfo = MPI_INFO_NULL;
+    rc = MPI_Win_get_info(win, &gotinfo);
+    test_verify("Win_get_info succeeds", MPI_SUCCESS == rc && MPI_INFO_NULL != gotinfo);
+    if (MPI_INFO_NULL != gotinfo) {
+        MPI_Info_free(&gotinfo);
+    }
+
+    /* predefined window attributes */
+    int flag = 0;
+    void *base = NULL;
+    MPI_Win_get_attr(win, MPI_WIN_BASE, &base, &flag);
+    test_verify("MPI_WIN_BASE present", 1 == flag);
+
+    MPI_Aint *sizep = NULL;
+    flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_SIZE, &sizep, &flag);
+    test_verify("MPI_WIN_SIZE present", 1 == flag);
+
+    int *dispp = NULL;
+    flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_DISP_UNIT, &dispp, &flag);
+    test_verify("MPI_WIN_DISP_UNIT present", 1 == flag);
+
+    int *flavorp = NULL;
+    flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_CREATE_FLAVOR, &flavorp, &flag);
+    test_verify("MPI_WIN_CREATE_FLAVOR present", 1 == flag);
+
+    int *modelp = NULL;
+    flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_MODEL, &modelp, &flag);
+    test_verify("MPI_WIN_MODEL present", 1 == flag);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_create(void)
+{
+    static int buffer[64];
+    MPI_Win win = MPI_WIN_NULL;
+    int rc = MPI_Win_create(buffer, sizeof(buffer), sizeof(int),
+                            MPI_INFO_NULL, MPI_COMM_SELF, &win);
+    test_verify("Win_create succeeds", MPI_SUCCESS == rc);
+    check_window_common("Win_create produced a window", win);
+
+    int *flavorp = NULL, flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_CREATE_FLAVOR, &flavorp, &flag);
+    test_verify("create flavor is MPI_WIN_FLAVOR_CREATE",
+                1 == flag && NULL != flavorp && MPI_WIN_FLAVOR_CREATE == *flavorp);
+
+    rc = MPI_Win_free(&win);
+    test_verify("Win_free succeeds", MPI_SUCCESS == rc);
+    test_verify("Win_free NULLs the handle", MPI_WIN_NULL == win);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_allocate(void)
+{
+    void *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+    int rc = MPI_Win_allocate(256, sizeof(int), MPI_INFO_NULL, MPI_COMM_SELF,
+                              &base, &win);
+    test_verify("Win_allocate succeeds", MPI_SUCCESS == rc);
+    test_verify("Win_allocate provided a buffer", NULL != base);
+    check_window_common("Win_allocate produced a window", win);
+
+    int *flavorp = NULL, flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_CREATE_FLAVOR, &flavorp, &flag);
+    test_verify("allocate flavor is MPI_WIN_FLAVOR_ALLOCATE",
+                1 == flag && NULL != flavorp && MPI_WIN_FLAVOR_ALLOCATE == *flavorp);
+
+    MPI_Win_free(&win);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_allocate_shared(void)
+{
+    void *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+    int rc = MPI_Win_allocate_shared(256, sizeof(int), MPI_INFO_NULL,
+                                     MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate_shared succeeds", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS != rc) {
+        return; /* shared-memory window may be unavailable in some configs */
+    }
+    check_window_common("Win_allocate_shared produced a window", win);
+
+    /* query the (only) rank's shared segment */
+    MPI_Aint qsize = -1;
+    int qdisp = -1;
+    void *qbase = NULL;
+    rc = MPI_Win_shared_query(win, 0, &qsize, &qdisp, &qbase);
+    test_verify("Win_shared_query succeeds", MPI_SUCCESS == rc);
+
+    MPI_Win_free(&win);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_create_dynamic(void)
+{
+    MPI_Win win = MPI_WIN_NULL;
+    int rc = MPI_Win_create_dynamic(MPI_INFO_NULL, MPI_COMM_SELF, &win);
+    test_verify("Win_create_dynamic succeeds", MPI_SUCCESS == rc);
+    check_window_common("Win_create_dynamic produced a window", win);
+
+    static int region[32];
+    rc = MPI_Win_attach(win, region, sizeof(region));
+    test_verify("Win_attach succeeds", MPI_SUCCESS == rc);
+
+    rc = MPI_Win_detach(win, region);
+    test_verify("Win_detach succeeds", MPI_SUCCESS == rc);
+
+    int *flavorp = NULL, flag = 0;
+    MPI_Win_get_attr(win, MPI_WIN_CREATE_FLAVOR, &flavorp, &flag);
+    test_verify("dynamic flavor is MPI_WIN_FLAVOR_DYNAMIC",
+                1 == flag && NULL != flavorp && MPI_WIN_FLAVOR_DYNAMIC == *flavorp);
+
+    MPI_Win_free(&win);
+}
diff --git a/ompi/test/general/win_notify.c b/ompi/test/general/win_notify.c
new file mode 100644
index 00000000000..05c2550024c
--- /dev/null
+++ b/ompi/test/general/win_notify.c
@@ -0,0 +1,594 @@
+/*
+ * Copyright (c) 2026      Joseph Antony.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for notified RMA communication (MPI-5.1 section 12.6): all
+ * eight notified communication operations, the notification counter
+ * management calls, and the counter accessors.
+ *
+ * Single process on MPI_COMM_SELF, so the target of every operation is
+ * this process itself.  That is enough to pin down the semantics this test
+ * cares about -- that each notified operation moves the data its
+ * non-notified counterpart would, and then increments exactly one
+ * notification counter by exactly one -- without needing a launcher.
+ *
+ * osc/sm is forced because it is currently the only osc component that
+ * implements the notified operations; on any other component the module's
+ * notify function pointers are NULL.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "support.h"
+
+#include "mpi.h"
+
+#define WIN_COUNT 8
+#define NUM_NOTIFY 4
+
+/* Comfortably more than the osc_sm_num_notify_counters default of 16, so that
+ * asking for this many forces the counters to be reallocated. */
+#define NUM_NOTIFY_GROWN 100
+
+static void test_counter_management(void);
+static void test_blocking_ops(void);
+static void test_request_ops(void);
+static void test_notify_idx_errors(void);
+static void test_counter_growth(void);
+static void test_max_num_notify_assertion(void);
+static void test_notify_attributes(void);
+
+/* Read notification counter "idx" and check it against "expect". */
+static void check_counter(MPI_Win win, int idx, MPI_Count expect,
+                          const char *what)
+{
+    MPI_Count value = -1;
+    int rc = MPI_Win_get_notify_value(win, idx, &value);
+    test_verify(what, MPI_SUCCESS == rc && expect == value);
+}
+
+int main(int argc, char *argv[])
+{
+    /* Must be set before MPI_Init: component selection happens there. */
+    setenv("OMPI_MCA_osc", "sm", 1);
+
+    test_init("ompi win_notify");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    test_counter_management();
+    test_blocking_ops();
+    test_request_ops();
+    test_notify_idx_errors();
+    test_counter_growth();
+    test_max_num_notify_assertion();
+    test_notify_attributes();
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+/* MPI-5.1 section 12.6.1: MPI_WIN_SET_NUM_NOTIFY / MPI_WIN_GET_NUM_NOTIFY,
+ * and the reset-to-zero behavior of the former. */
+static void test_counter_management(void)
+{
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+
+    int rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int),
+                              MPI_INFO_NULL, MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+
+    /* MPI-5.1 section 12.6.1 does not state how many counters are attached
+     * before the first MPI_WIN_SET_NUM_NOTIFY, and osc/sm and osc/ucx
+     * currently disagree (osc/sm pre-attaches its full reserved capacity,
+     * osc/ucx starts at zero -- see the note in osc_sm_component.c).  So
+     * only require that the query works and reports something sane; a
+     * portable program must call MPI_WIN_SET_NUM_NOTIFY first regardless. */
+    int num = -1;
+    rc = MPI_Win_get_num_notify(win, 0, &num);
+    test_verify("Win_get_num_notify succeeds before set", MPI_SUCCESS == rc);
+    test_verify("initial attached count is non-negative", num >= 0);
+
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, NUM_NOTIFY);
+    test_verify("Win_set_num_notify succeeds", MPI_SUCCESS == rc);
+
+    /* "A subsequent call to MPI_WIN_GET_NUM_NOTIFY will return the value
+     * given to MPI_WIN_SET_NUM_NOTIFY." */
+    num = -1;
+    rc = MPI_Win_get_num_notify(win, 0, &num);
+    test_verify("Win_get_num_notify returns what was set",
+                MPI_SUCCESS == rc && NUM_NOTIFY == num);
+
+    /* All counters start at zero. */
+    for (int i = 0; i < NUM_NOTIFY; ++i) {
+        check_counter(win, i, 0, "counter is zero after set_num_notify");
+    }
+
+    /* Bump a counter, then check that set_num_notify resets it: "All
+     * notification counters (both existing and newly attached) are reset to
+     * zero by this call." */
+    MPI_Win_lock_all(0, win);
+    int src = 1;
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 2, win);
+    test_verify("Put_notify succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    check_counter(win, 2, 1, "counter advanced before reset");
+    MPI_Win_unlock_all(win);
+
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, NUM_NOTIFY);
+    test_verify("Win_set_num_notify succeeds again", MPI_SUCCESS == rc);
+    check_counter(win, 2, 0, "set_num_notify resets existing counters");
+
+    /* MPI_WIN_RESET_NOTIFY_VALUE is an atomic fetch-and-zero. */
+    MPI_Win_lock_all(0, win);
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 1, win);
+    test_verify("Put_notify succeeds for reset test", MPI_SUCCESS == rc);
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 1, win);
+    test_verify("second Put_notify succeeds for reset test", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    MPI_Win_unlock_all(win);
+
+    MPI_Count value = -1;
+    rc = MPI_Win_reset_notify_value(win, 1, &value);
+    test_verify("Win_reset_notify_value returns the prior value",
+                MPI_SUCCESS == rc && 2 == value);
+    check_counter(win, 1, 0, "Win_reset_notify_value zeroes the counter");
+
+    MPI_Win_free(&win);
+}
+
+/* The four blocking notified operations. */
+static void test_blocking_ops(void)
+{
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+
+    int rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int),
+                              MPI_INFO_NULL, MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds (blocking ops)", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, NUM_NOTIFY);
+    test_verify("Win_set_num_notify succeeds (blocking ops)", MPI_SUCCESS == rc);
+
+    memset(base, 0, WIN_COUNT * sizeof(int));
+
+    /* Notified operations are permitted only during a passive target
+     * epoch (MPI-5.1 section 12.3). */
+    MPI_Win_lock_all(0, win);
+
+    /* --- MPI_PUT_NOTIFY --- */
+    int src = 42;
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win);
+    test_verify("Put_notify succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Put_notify moved the data", 42 == base[0]);
+    check_counter(win, 0, 1, "Put_notify incremented its counter by one");
+
+    /* --- MPI_GET_NOTIFY --- */
+    int dst = 0;
+    rc = MPI_Get_notify(&dst, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win);
+    test_verify("Get_notify succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Get_notify moved the data", 42 == dst);
+    check_counter(win, 0, 2, "Get_notify incremented its counter by one");
+
+    /* --- MPI_ACCUMULATE_NOTIFY --- */
+    src = 8;
+    rc = MPI_Accumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                               1, win);
+    test_verify("Accumulate_notify succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Accumulate_notify applied the op", 50 == base[0]);
+    check_counter(win, 1, 1, "Accumulate_notify incremented its counter by one");
+    check_counter(win, 0, 2, "Accumulate_notify left other counters alone");
+
+    /* MPI_REPLACE takes the other branch in the osc/sm accumulate path. */
+    src = 7;
+    rc = MPI_Accumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_REPLACE,
+                               1, win);
+    test_verify("Accumulate_notify with MPI_REPLACE succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Accumulate_notify applied MPI_REPLACE", 7 == base[0]);
+    check_counter(win, 1, 2, "Accumulate_notify/REPLACE incremented its counter");
+
+    /* --- MPI_GET_ACCUMULATE_NOTIFY --- */
+    src = 3;
+    int result = -1;
+    rc = MPI_Get_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                   0, 0, 1, MPI_INT, MPI_SUM, 2, win);
+    test_verify("Get_accumulate_notify succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Get_accumulate_notify fetched the prior value", 7 == result);
+    test_verify("Get_accumulate_notify applied the op", 10 == base[0]);
+    check_counter(win, 2, 1,
+                  "Get_accumulate_notify incremented its counter by one");
+
+    /* MPI_NO_OP fetches without modifying, and still notifies: the window
+     * was read, which is an access the notification covers. */
+    result = -1;
+    rc = MPI_Get_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                   0, 0, 1, MPI_INT, MPI_NO_OP, 2, win);
+    test_verify("Get_accumulate_notify with MPI_NO_OP succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Get_accumulate_notify/NO_OP fetched the value", 10 == result);
+    test_verify("Get_accumulate_notify/NO_OP left the window alone", 10 == base[0]);
+    check_counter(win, 2, 2,
+                  "Get_accumulate_notify/NO_OP incremented its counter");
+
+    MPI_Win_unlock_all(win);
+    MPI_Win_free(&win);
+}
+
+/* The four request-based notified operations.  Completion of the request
+ * indicates completion at the origin (MPI-5.1 section 12.6.4). */
+static void test_request_ops(void)
+{
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+
+    int rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int),
+                              MPI_INFO_NULL, MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds (request ops)", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, NUM_NOTIFY);
+    test_verify("Win_set_num_notify succeeds (request ops)", MPI_SUCCESS == rc);
+
+    memset(base, 0, WIN_COUNT * sizeof(int));
+
+    MPI_Win_lock_all(0, win);
+
+    MPI_Request req = MPI_REQUEST_NULL;
+
+    /* --- MPI_RPUT_NOTIFY --- */
+    int src = 42;
+    rc = MPI_Rput_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win, &req);
+    test_verify("Rput_notify succeeds", MPI_SUCCESS == rc);
+    rc = MPI_Wait(&req, MPI_STATUS_IGNORE);
+    test_verify("Wait on Rput_notify request succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Rput_notify moved the data", 42 == base[0]);
+    check_counter(win, 0, 1, "Rput_notify incremented its counter by one");
+
+    /* --- MPI_RGET_NOTIFY --- */
+    int dst = 0;
+    rc = MPI_Rget_notify(&dst, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win, &req);
+    test_verify("Rget_notify succeeds", MPI_SUCCESS == rc);
+    rc = MPI_Wait(&req, MPI_STATUS_IGNORE);
+    test_verify("Wait on Rget_notify request succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Rget_notify moved the data", 42 == dst);
+    check_counter(win, 0, 2, "Rget_notify incremented its counter by one");
+
+    /* --- MPI_RACCUMULATE_NOTIFY --- */
+    src = 8;
+    rc = MPI_Raccumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                                1, win, &req);
+    test_verify("Raccumulate_notify succeeds", MPI_SUCCESS == rc);
+    rc = MPI_Wait(&req, MPI_STATUS_IGNORE);
+    test_verify("Wait on Raccumulate_notify request succeeds", MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Raccumulate_notify applied the op", 50 == base[0]);
+    check_counter(win, 1, 1, "Raccumulate_notify incremented its counter by one");
+
+    /* --- MPI_RGET_ACCUMULATE_NOTIFY --- */
+    src = 3;
+    int result = -1;
+    rc = MPI_Rget_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                    0, 0, 1, MPI_INT, MPI_SUM, 2, win, &req);
+    test_verify("Rget_accumulate_notify succeeds", MPI_SUCCESS == rc);
+    rc = MPI_Wait(&req, MPI_STATUS_IGNORE);
+    test_verify("Wait on Rget_accumulate_notify request succeeds",
+                MPI_SUCCESS == rc);
+    MPI_Win_flush(0, win);
+    test_verify("Rget_accumulate_notify fetched the prior value", 50 == result);
+    test_verify("Rget_accumulate_notify applied the op", 53 == base[0]);
+    check_counter(win, 2, 1,
+                  "Rget_accumulate_notify incremented its counter by one");
+
+    MPI_Win_unlock_all(win);
+    MPI_Win_free(&win);
+}
+
+/* MPI-5.1 section 12.6: "Initiating a notified communication operation that
+ * references a notification counter that is out of range at the target is
+ * erroneous", reported as MPI_ERR_RMA_NOTIFICATION. */
+static void test_notify_idx_errors(void)
+{
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+
+    int rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int),
+                              MPI_INFO_NULL, MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds (error cases)", MPI_SUCCESS == rc);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, NUM_NOTIFY);
+    test_verify("Win_set_num_notify succeeds (error cases)", MPI_SUCCESS == rc);
+
+    memset(base, 0, WIN_COUNT * sizeof(int));
+
+    MPI_Win_lock_all(0, win);
+
+    int src = 1;
+    int result = 0;
+    MPI_Request req = MPI_REQUEST_NULL;
+
+    /* Negative index: rejected by the binding's parameter check. */
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, -1, win);
+    test_verify("Put_notify rejects a negative index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Accumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                               -1, win);
+    test_verify("Accumulate_notify rejects a negative index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Get_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                   0, 0, 1, MPI_INT, MPI_SUM, -1, win);
+    test_verify("Get_accumulate_notify rejects a negative index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Rput_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, -1, win, &req);
+    test_verify("Rput_notify rejects a negative index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Rget_notify(&result, 1, MPI_INT, 0, 0, 1, MPI_INT, -1, win, &req);
+    test_verify("Rget_notify rejects a negative index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Raccumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                                -1, win, &req);
+    test_verify("Raccumulate_notify rejects a negative index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Rget_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                    0, 0, 1, MPI_INT, MPI_SUM, -1, win, &req);
+    test_verify("Rget_accumulate_notify rejects a negative index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+
+    /* Index at or past the target's attached count: rejected by the osc
+     * module, which is the only layer that knows the target's count. */
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, NUM_NOTIFY, win);
+    test_verify("Put_notify rejects an out-of-range index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Accumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                               NUM_NOTIFY, win);
+    test_verify("Accumulate_notify rejects an out-of-range index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Get_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                   0, 0, 1, MPI_INT, MPI_SUM, NUM_NOTIFY, win);
+    test_verify("Get_accumulate_notify rejects an out-of-range index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Raccumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                                NUM_NOTIFY, win, &req);
+    test_verify("Raccumulate_notify rejects an out-of-range index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Rget_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                    0, 0, 1, MPI_INT, MPI_SUM, NUM_NOTIFY,
+                                    win, &req);
+    test_verify("Rget_accumulate_notify rejects an out-of-range index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+
+    /* An operation rejected for its index must not have touched the
+     * window, and must not have notified. */
+    test_verify("a rejected notified operation does not touch the window",
+                0 == base[0]);
+    for (int i = 0; i < NUM_NOTIFY; ++i) {
+        check_counter(win, i, 0,
+                      "a rejected notified operation does not notify");
+    }
+
+    /* The accessors validate their index too. */
+    MPI_Count value = -1;
+    rc = MPI_Win_get_notify_value(win, NUM_NOTIFY, &value);
+    test_verify("Win_get_notify_value rejects an out-of-range index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+    rc = MPI_Win_reset_notify_value(win, NUM_NOTIFY, &value);
+    test_verify("Win_reset_notify_value rejects an out-of-range index",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+
+    MPI_Win_unlock_all(win);
+    MPI_Win_free(&win);
+}
+
+/* ------------------------------------------------------------------ */
+
+/* MPI-5.1 section 12.2 defines the mpi_assert_max_num_notify info key with a
+ * default of 0, meaning "the implementation does not assume any limit on the
+ * number of notification counters".  A window created without the key must
+ * therefore honour a request for more counters than osc/sm reserves up front,
+ * which it does by moving the counters to a larger allocation. */
+static void test_counter_growth(void)
+{
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+    int rc;
+
+    rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int), MPI_INFO_NULL,
+                          MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds (growth)", MPI_SUCCESS == rc);
+    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+    memset(base, 0, WIN_COUNT * sizeof(int));
+
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, NUM_NOTIFY_GROWN);
+    test_verify("Win_set_num_notify grows past the reserved capacity",
+                MPI_SUCCESS == rc);
+
+    int num = -1;
+    rc = MPI_Win_get_num_notify(win, 0, &num);
+    test_verify("Win_get_num_notify returns the grown count",
+                MPI_SUCCESS == rc && NUM_NOTIFY_GROWN == num);
+
+    /* Every counter in the grown range must exist and read as zero. */
+    for (int i = 0; i < NUM_NOTIFY_GROWN; ++i) {
+        check_counter(win, i, 0, "grown counter is zero");
+    }
+
+    MPI_Win_lock_all(0, win);
+
+    /* An index only reachable after the growth must actually work end to end:
+     * the operation moves data and lands on the right counter. */
+    int src = 99;
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT,
+                        NUM_NOTIFY_GROWN - 1, win);
+    test_verify("Put_notify succeeds on a counter that only growth provided",
+                MPI_SUCCESS == rc);
+    test_verify("Put_notify moved the data after growth", 99 == base[0]);
+    check_counter(win, NUM_NOTIFY_GROWN - 1, 1,
+                  "the grown counter advanced by one");
+    check_counter(win, 0, 0, "the grown counter did not disturb its neighbours");
+
+    /* One past the grown range is still out of range. */
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT,
+                        NUM_NOTIFY_GROWN, win);
+    test_verify("Put_notify still rejects an index past the grown count",
+                MPI_ERR_RMA_NOTIFICATION == rc);
+
+    MPI_Win_unlock_all(win);
+    MPI_Win_free(&win);
+}
+
+/* A non-zero mpi_assert_max_num_notify is the user promising not to ask for
+ * more counters than that.  osc/sm reserves exactly that many and holds the
+ * user to the promise rather than silently reallocating. */
+static void test_max_num_notify_assertion(void)
+{
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+    MPI_Info info = MPI_INFO_NULL;
+    int rc;
+
+    MPI_Info_create(&info);
+    MPI_Info_set(info, "mpi_assert_max_num_notify", "8");
+
+    rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int), info,
+                          MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds with mpi_assert_max_num_notify",
+                MPI_SUCCESS == rc);
+    MPI_Info_free(&info);
+    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+    memset(base, 0, WIN_COUNT * sizeof(int));
+
+    /* Up to the asserted bound is fine. */
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, 8);
+    test_verify("Win_set_num_notify accepts the asserted maximum",
+                MPI_SUCCESS == rc);
+
+    int num = -1;
+    rc = MPI_Win_get_num_notify(win, 0, &num);
+    test_verify("Win_get_num_notify returns the asserted maximum",
+                MPI_SUCCESS == rc && 8 == num);
+
+    /* Past it is an error rather than a reallocation: the window was sized on
+     * the strength of the assertion. */
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, 9);
+    test_verify("Win_set_num_notify refuses to exceed the asserted maximum",
+                MPI_ERR_ARG == rc);
+
+    /* The refused call must not have disturbed the counters that do exist. */
+    rc = MPI_Win_get_num_notify(win, 0, &num);
+    test_verify("a refused Win_set_num_notify leaves the count alone",
+                MPI_SUCCESS == rc && 8 == num);
+
+    MPI_Win_lock_all(0, win);
+    int src = 7;
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 7, win);
+    test_verify("Put_notify works on the last asserted counter",
+                MPI_SUCCESS == rc);
+    check_counter(win, 7, 1, "the last asserted counter advanced");
+    MPI_Win_unlock_all(win);
+
+    MPI_Win_free(&win);
+}
+
+/* ------------------------------------------------------------------ */
+
+/* MPI-5.1 section 12.2.6, Table 12.1: the three notification bounds are cached
+ * on every window at creation.  NUM_SB and NUM_UB are int *, VALUE_UB is
+ * MPI_Count *. */
+static void test_notify_attributes(void)
+{
+    int *num_sb = NULL, *num_ub = NULL;
+    MPI_Count *value_ub = NULL;
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+    MPI_Info info = MPI_INFO_NULL;
+    int flag = 0, rc;
+
+    /* Without an assertion the reservation bounds what is served without
+     * reallocation, and nothing bounds what may be requested. */
+    rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int), MPI_INFO_NULL,
+                          MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds (attributes)", MPI_SUCCESS == rc);
+    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_NUM_SB, &num_sb, &flag);
+    test_verify("MPI_WIN_NOTIFICATION_NUM_SB is present",
+                MPI_SUCCESS == rc && flag && NULL != num_sb);
+    test_verify("MPI_WIN_NOTIFICATION_NUM_SB is positive", *num_sb > 0);
+
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_NUM_UB, &num_ub, &flag);
+    test_verify("MPI_WIN_NOTIFICATION_NUM_UB is present",
+                MPI_SUCCESS == rc && flag && NULL != num_ub);
+    test_verify("NUM_UB is unbounded when no assertion was given",
+                INT_MAX == *num_ub);
+
+    /* A suggested maximum above the hard maximum would be nonsense. */
+    test_verify("NUM_SB does not exceed NUM_UB", *num_sb <= *num_ub);
+
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_VALUE_UB, &value_ub, &flag);
+    test_verify("MPI_WIN_NOTIFICATION_VALUE_UB is present",
+                MPI_SUCCESS == rc && flag && NULL != value_ub);
+    test_verify("VALUE_UB is the full range of the counter type",
+                INT64_MAX == *value_ub);
+
+    /* Asking for exactly NUM_SB counters must not need a reallocation, and
+     * must be accepted. */
+    int sb = *num_sb;
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, sb);
+    test_verify("Win_set_num_notify accepts NUM_SB counters", MPI_SUCCESS == rc);
+
+    MPI_Win_free(&win);
+
+    /* With an assertion, both bounds collapse onto the asserted value. */
+    MPI_Info_create(&info);
+    MPI_Info_set(info, "mpi_assert_max_num_notify", "8");
+    rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int), info,
+                          MPI_COMM_SELF, &base, &win);
+    test_verify("Win_allocate succeeds (asserted attributes)", MPI_SUCCESS == rc);
+    MPI_Info_free(&info);
+    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_NUM_UB, &num_ub, &flag);
+    test_verify("NUM_UB reports the asserted maximum",
+                MPI_SUCCESS == rc && flag && 8 == *num_ub);
+
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_NUM_SB, &num_sb, &flag);
+    test_verify("NUM_SB reports the asserted maximum",
+                MPI_SUCCESS == rc && flag && 8 == *num_sb);
+
+    MPI_Win_free(&win);
+}
diff --git a/ompi/test/general/win_notify_unsupported.c b/ompi/test/general/win_notify_unsupported.c
new file mode 100644
index 00000000000..ac5754502f9
--- /dev/null
+++ b/ompi/test/general/win_notify_unsupported.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2026      Joseph Antony.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Notified RMA (MPI-5.1 section 12.6) is optional: an osc component that
+ * does not implement it leaves the corresponding entries of the module
+ * struct NULL.  Every notified entry point must report that as
+ * MPI_ERR_UNSUPPORTED_OPERATION rather than calling through a NULL
+ * function pointer.
+ *
+ * osc/rdma is forced because it is a general-purpose component that does
+ * not implement any of these, so it exercises the guard on all twelve
+ * entry points.  If it cannot be selected in this build the test reports
+ * that and passes trivially.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op
+ * here -- all verification must go through test_verify().
+ */
+
+#include "ompi_config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "support.h"
+
+#include "mpi.h"
+
+#define WIN_COUNT 8
+
+int main(int argc, char *argv[])
+{
+    /* Must be set before MPI_Init: component selection happens there. */
+    setenv("OMPI_MCA_osc", "rdma", 1);
+
+    test_init("ompi win_notify_unsupported");
+
+    int rc = MPI_Init(&argc, &argv);
+    test_verify("MPI_Init succeeds", MPI_SUCCESS == rc);
+
+    int *base = NULL;
+    MPI_Win win = MPI_WIN_NULL;
+    rc = MPI_Win_allocate(WIN_COUNT * sizeof(int), sizeof(int), MPI_INFO_NULL,
+                          MPI_COMM_SELF, &base, &win);
+    if (MPI_SUCCESS != rc) {
+        test_comment("osc/rdma not selectable in this build; skipping");
+        int r = test_finalize();
+        MPI_Finalize();
+        return r;
+    }
+    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);
+    memset(base, 0, WIN_COUNT * sizeof(int));
+
+    int src = 1;
+    int result = 0;
+    MPI_Count value = 0;
+    int num = 0;
+    MPI_Request req = MPI_REQUEST_NULL;
+
+    /* Counter management and the accessors are usable outside an epoch. */
+    rc = MPI_Win_set_num_notify(win, MPI_INFO_NULL, 4);
+    test_verify("Win_set_num_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Win_get_num_notify(win, 0, &num);
+    test_verify("Win_get_num_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Win_get_notify_value(win, 0, &value);
+    test_verify("Win_get_notify_value reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Win_reset_notify_value(win, 0, &value);
+    test_verify("Win_reset_notify_value reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+
+    MPI_Win_lock_all(0, win);
+
+    /* The four blocking communication operations. */
+    rc = MPI_Put_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win);
+    test_verify("Put_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Get_notify(&result, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win);
+    test_verify("Get_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Accumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                               0, win);
+    test_verify("Accumulate_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Get_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                   0, 0, 1, MPI_INT, MPI_SUM, 0, win);
+    test_verify("Get_accumulate_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+
+    /* The four request-based communication operations. */
+    rc = MPI_Rput_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win, &req);
+    test_verify("Rput_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Rget_notify(&result, 1, MPI_INT, 0, 0, 1, MPI_INT, 0, win, &req);
+    test_verify("Rget_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Raccumulate_notify(&src, 1, MPI_INT, 0, 0, 1, MPI_INT, MPI_SUM,
+                                0, win, &req);
+    test_verify("Raccumulate_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Rget_accumulate_notify(&src, 1, MPI_INT, &result, 1, MPI_INT,
+                                    0, 0, 1, MPI_INT, MPI_SUM, 0, win, &req);
+    test_verify("Rget_accumulate_notify reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+
+    /* The guard sits ahead of the MPI_PROC_NULL no-op, so an unsupported
+     * operation is reported identically no matter what the target is. */
+    rc = MPI_Put_notify(&src, 1, MPI_INT, MPI_PROC_NULL, 0, 1, MPI_INT, 0, win);
+    test_verify("Put_notify to MPI_PROC_NULL reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+    rc = MPI_Rput_notify(&src, 1, MPI_INT, MPI_PROC_NULL, 0, 1, MPI_INT, 0,
+                         win, &req);
+    test_verify("Rput_notify to MPI_PROC_NULL reports unsupported",
+                MPI_ERR_UNSUPPORTED_OPERATION == rc);
+
+    /* Nothing above should have moved any data. */
+    test_verify("no unsupported operation touched the window", 0 == base[0]);
+
+    /* MPI-5.1 section 12.2.6: the notification bounds are cached on every
+     * window, including one whose component cannot do notified communication at
+     * all.  Reporting zero there is the honest answer, and is consistent with
+     * every operation above having been refused. */
+    int *num_sb = NULL, *num_ub = NULL;
+    MPI_Count *value_ub = NULL;
+    int flag = 0;
+
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_NUM_SB, &num_sb, &flag);
+    test_verify("NUM_SB is present and zero without notification support",
+                MPI_SUCCESS == rc && flag && NULL != num_sb && 0 == *num_sb);
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_NUM_UB, &num_ub, &flag);
+    test_verify("NUM_UB is present and zero without notification support",
+                MPI_SUCCESS == rc && flag && NULL != num_ub && 0 == *num_ub);
+    rc = MPI_Win_get_attr(win, MPI_WIN_NOTIFICATION_VALUE_UB, &value_ub, &flag);
+    test_verify("VALUE_UB is present and zero without notification support",
+                MPI_SUCCESS == rc && flag && NULL != value_ub && 0 == *value_ub);
+
+    MPI_Win_unlock_all(win);
+    MPI_Win_free(&win);
+
+    int r = test_finalize();
+    MPI_Finalize();
+    return r;
+}
diff --git a/ompi/test/monitoring/Makefile.am b/ompi/test/monitoring/Makefile.am
new file mode 100644
index 00000000000..94e2cdb6b1d
--- /dev/null
+++ b/ompi/test/monitoring/Makefile.am
@@ -0,0 +1,48 @@
+#
+# Copyright (c) 2013-2017 The University of Tennessee and The University
+#                         of Tennessee Research Foundation.  All rights
+#                         reserved.
+# Copyright (c) 2013-2017 Inria.  All rights reserved.
+# Copyright (c) 2015-2017 Research Organization for Information Science
+#                         and Technology (RIST). All rights reserved.
+# Copyright (c) 2016      IBM Corporation.  All rights reserved.
+# Copyright (c) 2016      Cisco Systems, Inc.  All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+# This test requires multiple processes to run. Don't run it as part
+# of 'make check'
+noinst_PROGRAMS = monitoring_test test_pvar_access test_overhead check_monitoring example_reduce_count
+monitoring_test_SOURCES = monitoring_test.c
+monitoring_test_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+monitoring_test_LDADD = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+test_pvar_access_SOURCES = test_pvar_access.c
+test_pvar_access_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+test_pvar_access_LDADD = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+test_overhead_SOURCES = test_overhead.c
+test_overhead_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+test_overhead_LDADD = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+check_monitoring_SOURCES = check_monitoring.c
+check_monitoring_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+check_monitoring_LDADD = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+example_reduce_count_SOURCES = example_reduce_count.c
+example_reduce_count_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+example_reduce_count_LDADD = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+
+distclean-local:
+	rm -rf *.dSYM .deps .libs *.la *.lo monitoring_test test_pvar_access test_overhead check_monitoring example_reduce_count prof *.log *.o *.trs Makefile
diff --git a/test/monitoring/check_monitoring.c b/ompi/test/monitoring/check_monitoring.c
similarity index 100%
rename from test/monitoring/check_monitoring.c
rename to ompi/test/monitoring/check_monitoring.c
diff --git a/test/monitoring/example_reduce_count.c b/ompi/test/monitoring/example_reduce_count.c
similarity index 100%
rename from test/monitoring/example_reduce_count.c
rename to ompi/test/monitoring/example_reduce_count.c
diff --git a/test/monitoring/monitoring_test.c b/ompi/test/monitoring/monitoring_test.c
similarity index 100%
rename from test/monitoring/monitoring_test.c
rename to ompi/test/monitoring/monitoring_test.c
diff --git a/test/monitoring/test_overhead.c b/ompi/test/monitoring/test_overhead.c
similarity index 100%
rename from test/monitoring/test_overhead.c
rename to ompi/test/monitoring/test_overhead.c
diff --git a/test/monitoring/test_overhead.sh b/ompi/test/monitoring/test_overhead.sh
similarity index 100%
rename from test/monitoring/test_overhead.sh
rename to ompi/test/monitoring/test_overhead.sh
diff --git a/test/monitoring/test_pvar_access.c b/ompi/test/monitoring/test_pvar_access.c
similarity index 100%
rename from test/monitoring/test_pvar_access.c
rename to ompi/test/monitoring/test_pvar_access.c
diff --git a/test/spc/Makefile.am b/ompi/test/spc/Makefile.am
similarity index 73%
rename from test/spc/Makefile.am
rename to ompi/test/spc/Makefile.am
index 4652e3c4440..ae8e4d51b38 100644
--- a/test/spc/Makefile.am
+++ b/ompi/test/spc/Makefile.am
@@ -2,6 +2,7 @@
 # Copyright (c) 2018 The University of Tennessee and The University
 #                    of Tennessee Research Foundation.  All rights
 #                    reserved.
+# Copyright (c) 2026 Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -11,14 +12,12 @@
 
 # This test requires multiple processes to run. Don't run it as part
 # of 'make check'
-if PROJECT_OMPI
-    noinst_PROGRAMS = spc_test
-    spc_test_SOURCES = spc_test.c
-    spc_test_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-    spc_test_LDADD = \
+noinst_PROGRAMS = spc_test
+spc_test_SOURCES = spc_test.c
+spc_test_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+spc_test_LDADD = \
         $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
         $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-endif # PROJECT_OMPI
 
 distclean-local:
 	rm -rf *.dSYM .deps .libs *.la *.lo spc_test prof *.log *.o *.trs Makefile
diff --git a/test/spc/spc_test.c b/ompi/test/spc/spc_test.c
similarity index 100%
rename from test/spc/spc_test.c
rename to ompi/test/spc/spc_test.c
diff --git a/ompi/test/t/Makefile.am b/ompi/test/t/Makefile.am
new file mode 100644
index 00000000000..692ba01555e
--- /dev/null
+++ b/ompi/test/t/Makefile.am
@@ -0,0 +1,24 @@
+# -*- makefile -*-
+#
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+# $COPYRIGHT$
+#
+# Additional copyrights may follow
+#
+# $HEADER$
+#
+
+# These are singleton MPI_T tests: they exercise the MPI tool
+# information interface without MPI_Init, so they need no launcher and
+# can run as part of 'make check'.
+check_PROGRAMS = mpi_t_category_get_events
+TESTS = $(check_PROGRAMS)
+
+mpi_t_category_get_events_SOURCES = mpi_t_category_get_events.c
+mpi_t_category_get_events_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+mpi_t_category_get_events_LDADD = \
+        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+
+distclean-local:
+	rm -rf *.dSYM .deps .libs *.la *.lo mpi_t_category_get_events *.log *.o *.trs Makefile
diff --git a/ompi/test/t/mpi_t_category_get_events.c b/ompi/test/t/mpi_t_category_get_events.c
new file mode 100644
index 00000000000..c5781cc545b
--- /dev/null
+++ b/ompi/test/t/mpi_t_category_get_events.c
@@ -0,0 +1,88 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * Singleton (no launcher required) regression test for the cat_index
+ * validation performed by MPI_T_category_get_events and
+ * MPI_T_category_get_num_events.
+ *
+ * Both functions are specified with cat_index in the range
+ * [0, num_cat-1] (MPI-5.0 sec. 15.3.9).  An out-of-range index must be
+ * reported as MPI_T_ERR_INVALID_INDEX, consistent with the sibling
+ * MPI_T_category_get_{cvars,pvars,categories} query functions.  This
+ * test asserts that contract for cat_index = -1 and cat_index = num_cat,
+ * and that a valid index still returns MPI_SUCCESS (writing nothing
+ * while Open MPI registers no MPI_T events).
+ */
+
+#include <mpi.h>
+#include <stdio.h>
+
+static int failures = 0;
+
+static void check(const char *what, int got, int expected)
+{
+    if (got != expected) {
+        ++failures;
+        printf("FAIL: %s returned %d, expected %d\n", what, got, expected);
+    } else {
+        printf("PASS: %s returned %d\n", what, got);
+    }
+}
+
+int main(void)
+{
+    int provided, num_cat = 0, num_events = 0;
+    int indices[8];
+
+    MPI_T_init_thread(MPI_THREAD_SINGLE, &provided);
+    MPI_T_category_get_num(&num_cat);
+    printf("num_cat = %d\n", num_cat);
+
+    /* cat_index = -1 is always out of range, even when num_cat == 0. */
+    check("MPI_T_category_get_events(-1)",
+          MPI_T_category_get_events(-1, 8, indices),
+          MPI_T_ERR_INVALID_INDEX);
+    check("MPI_T_category_get_num_events(-1)",
+          MPI_T_category_get_num_events(-1, &num_events),
+          MPI_T_ERR_INVALID_INDEX);
+
+    /* cat_index = num_cat is one past the last valid index. */
+    check("MPI_T_category_get_events(num_cat)",
+          MPI_T_category_get_events(num_cat, 8, indices),
+          MPI_T_ERR_INVALID_INDEX);
+    check("MPI_T_category_get_num_events(num_cat)",
+          MPI_T_category_get_num_events(num_cat, &num_events),
+          MPI_T_ERR_INVALID_INDEX);
+
+    /* A valid index must still succeed (no events registered yet). */
+    if (num_cat > 0) {
+        check("MPI_T_category_get_events(0)",
+              MPI_T_category_get_events(0, 8, indices),
+              MPI_SUCCESS);
+
+        num_events = -1;
+        check("MPI_T_category_get_num_events(0)",
+              MPI_T_category_get_num_events(0, &num_events),
+              MPI_SUCCESS);
+        if (0 != num_events) {
+            ++failures;
+            printf("FAIL: MPI_T_category_get_num_events(0) wrote num_events=%d, "
+                   "expected 0\n", num_events);
+        }
+    }
+
+    MPI_T_finalize();
+
+    if (0 == failures) {
+        printf("All MPI_T category event index checks passed.\n");
+        return 0;
+    }
+    printf("%d MPI_T category event index check(s) failed.\n", failures);
+    return 1;
+}
diff --git a/ompi/tools/ompi_info/param.c b/ompi/tools/ompi_info/param.c
index f112bc5ed0c..d3d2694eef8 100644
--- a/ompi/tools/ompi_info/param.c
+++ b/ompi/tools/ompi_info/param.c
@@ -16,6 +16,7 @@
  * Copyright (c) 2015-2019 Intel, Inc.  All rights reserved.
  * Copyright (c) 2018-2022 Amazon.com, Inc. or its affiliates.  All Rights reserved.
  * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -108,7 +109,6 @@ void ompi_info_do_config(bool want_all)
     char *fortran_have_c_funloc;
     char *fortran_08_using_wrappers_for_choice_buffer_functions;
     char *fortran_build_sizeof;
-    char *java;
     char *heterogeneous;
     char *memprofile;
     char *memdebug;
@@ -257,7 +257,6 @@ void ompi_info_do_config(bool want_all)
         fortran_usempif08_compliance = "The mpi_f08 module was not built";
     }
 
-    java = OMPI_WANT_JAVA_BINDINGS ? "yes" : "no";
     heterogeneous = OPAL_ENABLE_HETEROGENEOUS_SUPPORT ? "yes" : "no";
     memprofile = OPAL_ENABLE_MEM_PROFILE ? "yes" : "no";
     memdebug = OPAL_ENABLE_MEM_DEBUG ? "yes" : "no";
@@ -277,7 +276,7 @@ void ompi_info_do_config(bool want_all)
     /* setup strings that require allocation */
     if (OMPI_BUILD_FORTRAN_BINDINGS >= OMPI_FORTRAN_MPIFH_BINDINGS) {
         (void)opal_asprintf(&fortran_mpifh, "yes (%s)",
-                       (OPAL_HAVE_WEAK_SYMBOLS ? "all" :
+                       (OPAL_HAVE_WEAK_ALIASES ? "all" :
                         (OMPI_FORTRAN_CAPS ? "caps" :
                          (OMPI_FORTRAN_PLAIN ? "lower case" :
                           (OMPI_FORTRAN_SINGLE_UNDERSCORE ? "single underscore" : "double underscore")))));
@@ -328,7 +327,8 @@ void ompi_info_do_config(bool want_all)
                   fortran_usempif08_compliance);
     opal_info_out("Fort mpi_f08 subarrays", "bindings:use_mpi_f08:subarrays-supported",
                   fortran_build_f08_subarrays);
-    opal_info_out("Java bindings", "bindings:java", java);
+    /* The Java bindings were removed in Open MPI v6.0.0. */
+    opal_info_out("Java bindings", "bindings:java", "no");
 
     opal_info_out("Wrapper compiler rpath", "compiler:all:rpath",
                   WRAPPER_RPATH_SUPPORT);
diff --git a/ompi/tools/wrappers/Makefile.am b/ompi/tools/wrappers/Makefile.am
index 1d5b24a9372..0f5d4525862 100644
--- a/ompi/tools/wrappers/Makefile.am
+++ b/ompi/tools/wrappers/Makefile.am
@@ -15,6 +15,7 @@
 # Copyright (c) 2014      Research Organization for Information Science
 #                         and Technology (RIST). All rights reserved.
 # Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -40,9 +41,6 @@ endif # OPAL_INSTALL_BINARIES
 if OPAL_WANT_SCRIPT_WRAPPER_COMPILERS
 
 bin_SCRIPTS = ompi_wrapper_script
-if OMPI_WANT_JAVA_BINDINGS
-bin_SCRIPTS += mpijavac.pl
-endif
 CLEANFILES += $(bin_SCRIPTS)
 
 install-exec-hook-always:
@@ -57,10 +55,6 @@ if OMPI_HAVE_FORTRAN_COMPILER
 	(cd $(DESTDIR)$(bindir); rm -f mpif77; $(LN_S) ompi_wrapper_script mpif77)
 	(cd $(DESTDIR)$(bindir); rm -f mpif90; $(LN_S) ompi_wrapper_script mpif90)
 endif
-if OMPI_WANT_JAVA_BINDINGS
-	(cp mpijavac.pl $(DESTDIR)$(bindir))
-	(cd $(DESTDIR)$(bindir); chmod +x mpijavac.pl; rm -f mpijavac; $(LN_S) mpijavac.pl mpijavac)
-endif
 
 uninstall-local-always:
 	rm -f $(DESTDIR)$(bindir)/mpicc \
@@ -68,8 +62,7 @@ uninstall-local-always:
 	$(DESTDIR)$(bindir)/mpicxx \
 	$(DESTDIR)$(bindir)/mpifort \
 	$(DESTDIR)$(bindir)/mpif77 \
-	$(DESTDIR)$(bindir)/mpif90 \
-	$(DESTDIR)$(bindir)/mpijavac
+	$(DESTDIR)$(bindir)/mpif90
 
 if CASE_SENSITIVE_FS_AND_HAVE_CXX_COMPILER
 install-exec-hook: install-exec-hook-always
@@ -85,10 +78,6 @@ else # OPAL_WANT_SCRIPT_WRAPPER_COMPILERS
 
 if OPAL_INSTALL_BINARIES
 
-if OMPI_WANT_JAVA_BINDINGS
-bin_SCRIPTS = mpijavac.pl
-endif
-
 nodist_ompidata_DATA = mpicc-wrapper-data.txt
 
 if OMPI_HAVE_CXX_COMPILER
@@ -111,10 +100,6 @@ if OMPI_HAVE_FORTRAN_COMPILER
 	(cd $(DESTDIR)$(bindir); rm -f mpif77$(EXEEXT); $(LN_S) opal_wrapper$(EXEEXT) mpif77$(EXEEXT))
 	(cd $(DESTDIR)$(bindir); rm -f mpif90$(EXEEXT); $(LN_S) opal_wrapper$(EXEEXT) mpif90$(EXEEXT))
 endif
-if OMPI_WANT_JAVA_BINDINGS
-	(cp mpijavac.pl $(DESTDIR)$(bindir))
-	(cd $(DESTDIR)$(bindir); chmod +x mpijavac.pl; rm -f mpijavac; $(LN_S) mpijavac.pl mpijavac)
-endif
 
 install-data-hook-always:
 if OMPI_HAVE_CXX_COMPILER
@@ -139,9 +124,7 @@ uninstall-local-always:
 	$(DESTDIR)$(pkgdatadir)/mpif90-wrapper-data.txt \
 	$(DESTDIR)$(pkgconfigdir)/ompi-f77.pc \
 	$(DESTDIR)$(pkgconfigdir)/ompi-f90.pc \
-	$(DESTDIR)$(pkgconfigdir)/ompi-fort.pc \
-	$(DESTDIR)$(bindir)/mpijavac \
-	$(DESTDIR)$(bindir)/mpijavac.pl
+	$(DESTDIR)$(pkgconfigdir)/ompi-fort.pc
 
 if CASE_SENSITIVE_FS_AND_HAVE_CXX_COMPILER
 install-exec-hook: install-exec-hook-always
diff --git a/ompi/tools/wrappers/mpijavac.pl.in b/ompi/tools/wrappers/mpijavac.pl.in
deleted file mode 100644
index f8aeb747452..00000000000
--- a/ompi/tools/wrappers/mpijavac.pl.in
+++ /dev/null
@@ -1,145 +0,0 @@
-#!/usr/bin/env perl
-
-# WARNING: DO NOT EDIT THE mpijava.pl FILE AS IT IS GENERATED!
-#          MAKE ALL CHANGES IN mpijava.pl.in
-
-# Copyright (c) 2011-2013 Cisco Systems, Inc.  All rights reserved.
-# Copyright (c) 2012      Oracle and/or its affiliates.  All rights reserved.
-
-use strict;
-
-# The main purpose of this wrapper compiler is to check for
-# and adjust the Java class path to include the OMPI classes
-# in mpi.jar. The user may have specified a class path on
-# our cmd line, or it may be in the environment, so we have
-# to check for both. We also need to be careful not to
-# just override the class path as it probably includes classes
-# they need for their application! It also may already include
-# the path to mpi.jar, and while it doesn't hurt anything, we
-# don't want to include our class path more than once to avoid
-# user astonishment
-
-# Let the build system provide us with some critical values
-my $my_compiler = "@JAVAC@";
-my $mpi_jar   = "@OMPI_WRAPPER_LIBDIR@/mpi.jar";
-my $shmem_jar = "@OMPI_WRAPPER_LIBDIR@/shmem.jar";
-
-# globals
-my $showme_arg = 0;
-my $verbose = 0;
-my $my_arg;
-
-# Cannot use the usual GetOpts library as the user might
-# be passing -options to the Java compiler! So have to
-# parse the options ourselves to look for help and showme
-my @save_args;
-foreach $my_arg (@ARGV) {
-    if ($my_arg eq "-h" ||
-        $my_arg eq "--h" ||
-        $my_arg eq "-help" ||
-        $my_arg eq "--help") {
-        print "Options:
-  --showme                      Show the wrapper compiler command without executing it
-  --verbose                     Show the wrapper compiler command *and* execute it
-  --help | -h                   This help list\n";
-        exit(0);
-    } elsif ($my_arg eq "--showme") {
-        $showme_arg = 1;
-    } elsif ($my_arg eq "--verbose") {
-        $verbose = 1;
-    } else {
-        push(@save_args, $my_arg);
-    }
-}
-
-# Create a place to save our argv array so we can edit any
-# provide class path option
-my @arguments = ();
-
-# Check the command line for a class path
-my $cp_found = 0;
-my $my_cp;
-foreach $my_arg (@save_args) {
-    if (1 == $cp_found) {
-        $my_cp = $my_arg;
-        if (0 > index($my_arg, "mpi.jar")) {
-            # not found, so we add our path
-            if (rindex($my_arg, ":") == length($my_arg)-1) {
-                # already have a colon at the end
-                $my_cp = $my_cp . $mpi_jar;
-            } else {
-                # need to add the colon between paths
-                $my_cp = $my_cp . ":" . $mpi_jar;
-            }
-        }
-        if (0 > index($my_arg, "shmem.jar")) {
-            # not found, so we add our path
-            if (rindex($my_arg, ":") == length($my_arg)-1) {
-                # already have a colon at the end
-                $my_cp = $my_cp . $shmem_jar;
-            } else {
-                # need to add the colon between paths
-                $my_cp = $my_cp . ":" . $shmem_jar;
-            }
-        }
-        push(@arguments, $my_cp);
-        $cp_found = 2;
-    } else {
-        if (0 == $cp_found && (
-            0 <= index($my_arg, "-cp") ||
-            0 <= index($my_arg, "-classpath")))
-        {
-            $cp_found = 1;
-        }
-        push(@arguments, $my_arg);
-    }
-}
-
-# If the class path wasn't found on the cmd line, then
-# we next check the class path in the environment, if it exists
-if (2 != $cp_found && exists $ENV{'CLASSPATH'} && length($ENV{'CLASSPATH'}) > 0) {
-    $my_cp = $ENV{'CLASSPATH'};
-    if(0 > index($my_cp, "mpi.jar")) {
-        # not found, so we add our path
-        if (rindex($my_cp, ":") == length($my_cp)-1) {
-            # already have a colon at the end
-            $my_cp = $my_cp . $mpi_jar;
-        } else {
-            # need to add the colon between paths
-            $my_cp = $my_cp . ":" . $mpi_jar;
-        }
-    }
-    if (0 > index($my_cp, "shmem.jar")) {
-        # not found, so we add our path
-        if (rindex($my_cp, ":") == length($my_cp)-1) {
-            # already have a colon at the end
-            $my_cp = $my_cp . $shmem_jar;
-        } else {
-            # need to add the colon between paths
-            $my_cp = $my_cp . ":" . $shmem_jar;
-        }
-    }
-    unshift(@arguments, $my_cp);
-    unshift(@arguments, "-cp");
-    # ensure we mark that we "found" the class path
-    $cp_found = 1;
-}
-
-# If the class path wasn't found in either location, then
-# we have to insert it as the first argument
-if (0 == $cp_found) {
-    unshift(@arguments, $mpi_jar . ":" . $shmem_jar);
-    unshift(@arguments, "-cp");
-}
-
-# Construct the command
-my $returnCode = 0;
-if ($showme_arg) {
-    print "$my_compiler @arguments\n";
-} else {
-    if ($verbose) {
-        print "$my_compiler @arguments\n";
-    }
-    $returnCode = system $my_compiler, @arguments;
-}
-exit $returnCode;
diff --git a/ompi/util/count_disp_array.h b/ompi/util/count_disp_array.h
index f95d65dc858..61780b3fc14 100644
--- a/ompi/util/count_disp_array.h
+++ b/ompi/util/count_disp_array.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2024   Triad National Security, LLC. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -9,125 +10,107 @@
 #ifndef OMPI_UTIL_COUNT_DISP_ARRAY_H
 #define OMPI_UTIL_COUNT_DISP_ARRAY_H
 
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdint.h>
+#include "opal/util/count_disp_array.h"
 
 /*
  * NOTE: This code chooses between 64-bit and 32-bit pointers by using the
  *       least significant bit as a flag (which is possible since these
  *       pointers will always be multiples of 4 or 8).
  */
-typedef intptr_t ompi_count_array_t;
+typedef opal_count_array_t ompi_count_array_t;
+
+#define OMPI_COUNT_ARRAY_NULL OPAL_COUNT_ARRAY_NULL
 
 /* Initialize an int variant of the count array */
 static inline void ompi_count_array_init(ompi_count_array_t *array, const int *data)
 {
-    *array = (intptr_t)data | 0x1L;
+    opal_count_array_init(array, data);
 }
 
 /* Initialize a bigcount variant of the count array */
 static inline void ompi_count_array_init_c(ompi_count_array_t *array, const size_t *data)
 {
-    *array = (intptr_t)data;
+    opal_count_array_init_c(array, data);
 }
 
-#if OPAL_C_HAVE__GENERIC
-#define OMPI_COUNT_ARRAY_INIT(array, data) _Generic((data), \
-                                                    int *: ompi_count_array_init, \
-                                                    const int *: ompi_count_array_init, \
-                                                    size_t *: ompi_count_array_init_c, \
-                                                    const size_t *: ompi_count_array_init_c, \
-                                                    const MPI_Count *: ompi_count_array_init_c)(array, (const void *) data)
-#else
-#define OMPI_COUNT_ARRAY_INIT(array, data) \
-    do { \
-        if (sizeof(*(data)) == sizeof(int)) { \
-            ompi_count_array_init(array, (const int *) (data)); \
-        } else if (sizeof(*(data)) == sizeof(size_t)) { \
-            ompi_count_array_init_c(array, (const size_t *) (data)); \
-        } \
-    } while (0)
-#endif
+#define OMPI_COUNT_ARRAY_INIT(array, data) OPAL_COUNT_ARRAY_INIT(array, data)
+
+
+static inline ompi_count_array_t ompi_count_array_create(const int *data)
+{
+    return opal_count_array_create(data);
+}
+
+static inline ompi_count_array_t ompi_count_array_create_c(const size_t *data)
+{
+    return opal_count_array_create_c(data);
+}
+
+#define OMPI_COUNT_ARRAY_CREATE(data) OPAL_COUNT_ARRAY_CREATE(data)
 
 /* Return if the internal type is 64-bit or not */
 static inline bool ompi_count_array_is_64bit(ompi_count_array_t array)
 {
-    return !(array & 0x1L) && sizeof(size_t) == 8;
+    return opal_count_array_is_64bit(array);
 }
 
 static inline const void *ompi_count_array_ptr(ompi_count_array_t array)
 {
-    if (OPAL_LIKELY(array & 0x1L)){
-        return (const void *)(array & ~0x1L);
-    }
-    return (const void *) array;
+    return opal_count_array_ptr(array);
 }
 
 /* Get a count in the array at index i */
 static inline size_t ompi_count_array_get(ompi_count_array_t array, size_t i)
 {
-    if (OPAL_LIKELY(array & 0x1L)){
-        const int *iptr = (const int *)(array & ~0x1L);
-        return iptr[i];
-    }
-    return ((const size_t *)array)[i];
+    return opal_count_array_get(array, i);
 }
 
-typedef intptr_t ompi_disp_array_t;
+typedef opal_disp_array_t ompi_disp_array_t;
+
+#define OMPI_DISP_ARRAY_NULL OPAL_DISP_ARRAY_NULL
 
 /* Initialize an int variant of the disp array */
 static inline void ompi_disp_array_init(ompi_disp_array_t *array, const int *data)
 {
-    *array = (intptr_t)data | 0x1L;
+    opal_disp_array_init(array, data);
 }
 
 /* Initialize a bigcount variant of the disp array */
 static inline void ompi_disp_array_init_c(ompi_disp_array_t *array, const ptrdiff_t *data)
 {
-    *array = (intptr_t)data;
+    opal_disp_array_init_c(array, data);
 }
 
-#if OPAL_C_HAVE__GENERIC
-#define OMPI_DISP_ARRAY_INIT(array, data) _Generic((data), \
-                                                   int *: ompi_disp_array_init, \
-                                                   const int *: ompi_disp_array_init, \
-                                                   ptrdiff_t *: ompi_disp_array_init_c, \
-                                                   const ptrdiff_t *: ompi_disp_array_init_c)(array, data)
-#else
-#define OMPI_DISP_ARRAY_INIT(array, data) \
-    do { \
-        if (sizeof(*(data)) == sizeof(int)) { \
-            ompi_disp_array_init(array, (const int *) (data)); \
-        } else if (sizeof(*(data)) == sizeof(ptrdiff_t)) { \
-            ompi_disp_array_init_c(array, (const ptrdiff_t *) (data)); \
-        } \
-    } while(0)
-#endif
+#define OMPI_DISP_ARRAY_INIT(array, data) OPAL_DISP_ARRAY_INIT(array, data)
+
+static inline ompi_disp_array_t ompi_disp_array_create(const int *data)
+{
+    return opal_disp_array_create(data);
+}
+
+static inline ompi_disp_array_t ompi_disp_array_create_c(const ptrdiff_t *data)
+{
+    return opal_disp_array_create_c(data);
+}
+
+#define OMPI_DISP_ARRAY_CREATE(data) OPAL_DISP_ARRAY_CREATE(data)
 
 /* Return if the internal type is 64-bit or not */
 static inline bool ompi_disp_array_is_64bit(ompi_disp_array_t array)
 {
-    return !(array & 0x1L) && sizeof(ptrdiff_t) == 8;
+    return opal_disp_array_is_64bit(array);
 }
 
 /* Get a displacement in the array at index i */
 static inline ptrdiff_t ompi_disp_array_get(ompi_disp_array_t array, size_t i)
 {
-    if (OPAL_LIKELY(array & 0x1L)){
-        const int *iptr = (const int *)(array & ~0x1L);
-        return iptr[i];
-    }
-    return ((const ptrdiff_t *)array)[i];
+    return opal_disp_array_get(array, i);
 }
 
 /* Get a direct pointer to the data */
 static inline const void *ompi_disp_array_ptr(ompi_disp_array_t array)
 {
-    if (OPAL_LIKELY(array & 0x1L)){
-        return (const void *)(array & ~0x1L);
-    }
-    return (const void *)array;
+    return opal_disp_array_ptr(array);
 }
 
 #endif
diff --git a/ompi/win/win.c b/ompi/win/win.c
index 8b29e88b857..69d096e53e9 100644
--- a/ompi/win/win.c
+++ b/ompi/win/win.c
@@ -17,7 +17,7 @@
  * Copyright (c) 2015-2017 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
- * Copyright (c) 2018-2025 Triad National Security, LLC. All rights
+ * Copyright (c) 2018-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2024      Advanced Micro Devices, Inc. All rights reserved.
  * $COPYRIGHT$
@@ -129,7 +129,7 @@ int ompi_win_init (void)
     ompi_mpi_win_null.win.w_flags = OMPI_WIN_INVALID;
     ompi_mpi_win_null.win.w_group = &ompi_mpi_group_null.group;
     OBJ_RETAIN(&ompi_mpi_group_null);
-    ompi_win_set_name(&ompi_mpi_win_null.win, "MPI_WIN_NULL");
+    ompi_mpi_win_null.win.w_name = strdup ("MPI_WIN_NULL");
     opal_pointer_array_set_item(&ompi_mpi_windows, 0, &ompi_mpi_win_null.win);
 
     ret = mca_base_var_enum_create ("accumulate_ops", accumulate_ops_values, &ompi_win_accumulate_ops);
@@ -164,6 +164,13 @@ static int alloc_window(struct ompi_communicator_t *comm, opal_info_t *info, int
         return OMPI_ERR_OUT_OF_RESOURCE;
     }
 
+    win->w_name = (char*) malloc (OPAL_MAX_OBJECT_NAME);
+    if (NULL == win->w_name) {
+        OBJ_RELEASE(win);
+        return OMPI_ERR_OUT_OF_RESOURCE;
+    }
+    win->w_name[0] = '\0';
+
     /* Copy the info for the info layer */
     win->super.s_info = OBJ_NEW(opal_info_t);
     if (info) {
@@ -242,6 +249,45 @@ config_window(void *base, size_t size, ptrdiff_t disp_unit,
                             MPI_WIN_MODEL, model, true);
     if (OMPI_SUCCESS != ret) return ret;
 
+    /* MPI-5.1 section 12.2.6, Table 12.1: the notification bounds are cached on
+     * every window, whether or not its component implements notified
+     * communication.  A component that does not leaves the query NULL and the
+     * attributes read as zero -- no counter may be attached to such a window,
+     * which is exactly what MPI_Win_set_num_notify would report by returning
+     * MPI_ERR_UNSUPPORTED_OPERATION. */
+    int notify_num_sb = 0, notify_num_ub = 0;
+    MPI_Count notify_value_ub = 0;
+
+    if (NULL != win->w_osc_module->osc_win_get_notify_bounds) {
+        ret = win->w_osc_module->osc_win_get_notify_bounds(win, &notify_num_sb,
+                                                           &notify_num_ub,
+                                                           &notify_value_ub);
+        if (OMPI_SUCCESS != ret) return ret;
+    }
+
+    ret = ompi_attr_set_int(WIN_ATTR, win,
+                            &win->w_keyhash,
+                            MPI_WIN_NOTIFICATION_NUM_SB, notify_num_sb, true);
+    if (OMPI_SUCCESS != ret) return ret;
+
+    ret = ompi_attr_set_int(WIN_ATTR, win,
+                            &win->w_keyhash,
+                            MPI_WIN_NOTIFICATION_NUM_UB, notify_num_ub, true);
+    if (OMPI_SUCCESS != ret) return ret;
+
+    /* MPI-5.1 Table 12.1 types this attribute MPI_Count *, and the attribute
+     * machinery has no MPI_Count slot -- every other predefined attribute is
+     * integer- or address-valued.  Storing it as an MPI_Aint is safe because
+     * MPI_Aint tracks the pointer width and Open MPI no longer supports 32-bit
+     * environments, so the two are the same width wherever this runs and the
+     * value round-trips to the user unchanged.  Should 32-bit ever come back,
+     * this needs a real MPI_Count slot in attribute_value_t instead. */
+    ret = ompi_attr_set_aint(WIN_ATTR, win,
+                             &win->w_keyhash,
+                             MPI_WIN_NOTIFICATION_VALUE_UB,
+                             (MPI_Aint) notify_value_ub, true);
+    if (OMPI_SUCCESS != ret) return ret;
+
     win->w_f_to_c_index = opal_pointer_array_add(&ompi_mpi_windows, win);
     if (-1 == win->w_f_to_c_index) return OMPI_ERR_OUT_OF_RESOURCE;
 
@@ -432,7 +478,7 @@ static void
 ompi_win_construct(ompi_win_t *win)
 {
     OBJ_CONSTRUCT(&win->w_lock, opal_mutex_t);
-    win->w_name[0] = '\0';
+    win->w_name = NULL;
     win->w_group = NULL;
     win->w_keyhash = NULL;
     win->w_f_to_c_index = 0;
@@ -464,5 +510,10 @@ ompi_win_destruct(ompi_win_t *win)
         OBJ_RELEASE(win->w_group);
     }
 
+    if (NULL != win->w_name) {
+        free (win->w_name);
+        win->w_name = NULL;
+    }
+
     OBJ_DESTRUCT(&win->w_lock);
 }
diff --git a/ompi/win/win.h b/ompi/win/win.h
index ebffd848e47..855d920eb43 100644
--- a/ompi/win/win.h
+++ b/ompi/win/win.h
@@ -15,7 +15,7 @@
  * Copyright (c) 2013-2015 Los Alamos National Security, LLC.  All rights
  *                         reserved.
  * Copyright (c) 2016-2017 IBM Corporation. All rights reserved.
- * Copyright (c) 2018-2025 Triad National Security, LLC. All rights
+ * Copyright (c) 2018-2026 Triad National Security, LLC. All rights
  *                         reserved.
  * $COPYRIGHT$
  *
@@ -81,7 +81,7 @@ struct ompi_win_t {
 
     opal_mutex_t  w_lock;
 
-    char w_name[MPI_MAX_OBJECT_NAME];
+    char *w_name;
   
     /* Group associated with this window. */
     ompi_group_t *w_group;
diff --git a/opal/class/opal_bitmap.c b/opal/class/opal_bitmap.c
index 5d39dbc1933..80666dc5bb5 100644
--- a/opal/class/opal_bitmap.c
+++ b/opal/class/opal_bitmap.c
@@ -14,7 +14,7 @@
  * Copyright (c) 2014      Intel, Inc. All rights reserved.
  * Copyright (c) 2015-2017 Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
- * Copyright (c) 2025      Jeffrey M. Squyres. All rights reserved.
+ * Copyright (c) 2025-2026 Jeffrey M. Squyres. All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -62,32 +62,34 @@ int opal_bitmap_set_max_size(opal_bitmap_t *bm, int max_size)
     }
 
     /*
-     * Only if the caller wants to set the maximum size,
-     * we set it (in numbers of bits!), otherwise it is
-     * set to INT_MAX in the constructor.
+     * Store the cap in bits, matching the documented contract (see the
+     * header).  When the caller does not set it, it is INT_MAX (set in
+     * the constructor).
      */
-    bm->max_size = (int) (((size_t) max_size + SIZE_OF_BASE_TYPE - 1) / SIZE_OF_BASE_TYPE);
+    bm->max_size = max_size;
 
     return OPAL_SUCCESS;
 }
 
 int opal_bitmap_init(opal_bitmap_t *bm, int size)
 {
+    if ((size <= 0) || (NULL == bm)) {
+        return OPAL_ERR_BAD_PARAM;
+    }
+
     /*
-     * Only if the caller set the maximum size before initializing,
-     * we test here (in numbers of bits!)
-     * By default, the max size is INT_MAX, set in the constructor.
+     * Enforce the optional maximum (in bits) on the requested size before
+     * rounding up to a whole number of array elements.  bm->max_size is
+     * expressed in bits (see opal_bitmap_set_max_size()); by default it is
+     * INT_MAX, set in the constructor.
      */
-    if ((size <= 0) || (NULL == bm) || (size > bm->max_size)) {
+    if (size > bm->max_size) {
         return OPAL_ERR_BAD_PARAM;
     }
 
     bm->array_size = (int) (((size_t) size + SIZE_OF_BASE_TYPE - 1) / SIZE_OF_BASE_TYPE);
     if (NULL != bm->bitmap) {
         free(bm->bitmap);
-        if (bm->max_size < bm->array_size) {
-            bm->max_size = bm->array_size;
-        }
     }
     bm->bitmap = (uint64_t *) malloc(bm->array_size * sizeof(uint64_t));
     if (NULL == bm->bitmap) {
@@ -100,9 +102,11 @@ int opal_bitmap_init(opal_bitmap_t *bm, int size)
 
 int opal_bitmap_set_bit(opal_bitmap_t *bm, int bit)
 {
-    int index, offset, new_size;
+    int index, offset, new_size, max_array_size;
 
-    if ((bit < 0) || (NULL == bm) || (bit > bm->max_size)) {
+    /* bm->max_size is the optional cap in bits; valid bit indices are
+       0 .. max_size-1. */
+    if ((bit < 0) || (NULL == bm) || (bit >= bm->max_size)) {
         return OPAL_ERR_BAD_PARAM;
     }
 
@@ -116,8 +120,13 @@ int opal_bitmap_set_bit(opal_bitmap_t *bm, int bit)
          valid and we simply expand the bitmap */
 
         new_size = index + 1;
-        if (new_size > bm->max_size) {
-            new_size = bm->max_size;
+        /* Clamp growth to the cap, converted from bits to array elements.
+           The bit-range check above already guarantees new_size stays
+           within this bound, but keep the clamp consistent with max_size. */
+        max_array_size = (int) (((size_t) bm->max_size + SIZE_OF_BASE_TYPE - 1)
+                                / SIZE_OF_BASE_TYPE);
+        if (new_size > max_array_size) {
+            new_size = max_array_size;
         }
 
         /* New size is just a multiple of the original size to fit in
@@ -226,6 +235,22 @@ int opal_bitmap_find_and_set_first_unset_bit(opal_bitmap_t *bm, int *position)
     }
 
     (*position) += i * SIZE_OF_BASE_TYPE;
+
+    /*
+     * The fast path above sets the first unset bit in word i directly,
+     * without consulting bm->max_size.  When max_size is not a multiple of
+     * SIZE_OF_BASE_TYPE, the last allocated word can contain unset bits that
+     * lie beyond the cap, so this path can otherwise hand back (and set) a
+     * bit at/after max_size.  If that happened the bitmap is full within its
+     * valid range [0, max_size): undo the speculative set and report it,
+     * matching opal_bitmap_set_bit() -- which the all-words-full grow path
+     * above already goes through.
+     */
+    if (*position >= bm->max_size) {
+        bm->bitmap[i] &= ~(1UL << (*position - i * SIZE_OF_BASE_TYPE));
+        return OPAL_ERR_BAD_PARAM;
+    }
+
     return OPAL_SUCCESS;
 }
 
diff --git a/opal/class/opal_graph.c b/opal/class/opal_graph.c
index aa4f787fd74..095d61cdf7a 100644
--- a/opal/class/opal_graph.c
+++ b/opal/class/opal_graph.c
@@ -14,6 +14,7 @@
  * Copyright (c) 2016-2017 Los Alamos National Security, LLC. All rights
  *                         reserved.
  * Copyright (c) 2016 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026 Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -179,6 +180,8 @@ static void delete_all_edges_conceded_to_vertex(opal_graph_t *graph, opal_graph_
                 opal_list_remove_item(edge->in_adj_list->edges, (opal_list_item_t *) edge);
                 /* distract this edge */
                 OBJ_RELEASE(edge);
+                /* keep the graph's edge count in sync */
+                graph->number_of_edges--;
             }
         }
     }
@@ -298,8 +301,11 @@ void opal_graph_remove_vertex(opal_graph_t *graph, opal_graph_vertex_t *vertex)
     adj_list = vertex->in_adj_list;
     /**
      * remove the adjscency list of this vertex from the graph and
-     * destruct it.
+     * destruct it.  The outgoing edges of this vertex are released
+     * along with the adjacency list, so account for them in the graph's
+     * edge count.
      */
+    graph->number_of_edges -= opal_list_get_size(adj_list->edges);
     opal_list_remove_item(graph->adjacency_list, (opal_list_item_t *) adj_list);
     OBJ_RELEASE(adj_list);
     /**
diff --git a/opal/datatype/opal_convertor.c b/opal/datatype/opal_convertor.c
index 8550683a60d..2780f3ce604 100644
--- a/opal/datatype/opal_convertor.c
+++ b/opal/datatype/opal_convertor.c
@@ -17,6 +17,7 @@
  * Copyright (c) 2017      Intel, Inc. All rights reserved
  * Copyright (c) 2022      Amazon.com, Inc. or its affiliates.  All Rights reserved.
  * Copyright (c) 2022      Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -253,7 +254,7 @@ int32_t opal_convertor_pack(opal_convertor_t *pConv, struct iovec *iov, uint32_t
          * environment. The convertor contain minimal information, we only
          * use the bConverted to manage the conversion.
          */
-        uint32_t i;
+        size_t i;
         unsigned char *base_pointer;
         size_t pending_length = pConv->local_size - pConv->bConverted;
 
@@ -303,7 +304,7 @@ int32_t opal_convertor_unpack(opal_convertor_t *pConv, struct iovec *iov, uint32
          * environment. The convertor contain minimal information, we only
          * use the bConverted to manage the conversion.
          */
-        uint32_t i;
+        size_t i;
         unsigned char *base_pointer;
         size_t pending_length = pConv->local_size - pConv->bConverted;
 
diff --git a/opal/datatype/opal_datatype.h b/opal/datatype/opal_datatype.h
index 5e953ccfb6b..48203487822 100644
--- a/opal/datatype/opal_datatype.h
+++ b/opal/datatype/opal_datatype.h
@@ -20,6 +20,7 @@
  *                         reserved.
  * Copyright (c) 2018      FUJITSU LIMITED.  All rights reserved.
  * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -196,8 +197,8 @@ OPAL_DECLSPEC extern const opal_datatype_t opal_datatype_unsigned_long;
  */
 int opal_datatype_register_params(void);
 OPAL_DECLSPEC int32_t opal_datatype_init(void);
-OPAL_DECLSPEC opal_datatype_t *opal_datatype_create(int32_t expectedSize);
-OPAL_DECLSPEC int32_t opal_datatype_create_desc(opal_datatype_t *datatype, int32_t expectedSize);
+OPAL_DECLSPEC opal_datatype_t *opal_datatype_create(ssize_t expectedSize);
+OPAL_DECLSPEC int32_t opal_datatype_create_desc(opal_datatype_t *datatype, ssize_t expectedSize);
 OPAL_DECLSPEC int32_t opal_datatype_commit(opal_datatype_t *pData);
 OPAL_DECLSPEC int32_t opal_datatype_destroy(opal_datatype_t **);
 OPAL_DECLSPEC int32_t opal_datatype_is_monotonic(opal_datatype_t *type);
diff --git a/opal/datatype/opal_datatype_add.c b/opal/datatype/opal_datatype_add.c
index 2618ad3ba5b..72607a67e07 100644
--- a/opal/datatype/opal_datatype_add.c
+++ b/opal/datatype/opal_datatype_add.c
@@ -14,6 +14,7 @@
  * Copyright (c) 2014      Cisco Systems, Inc.  All rights reserved.
  * Copyright (c) 2017      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -127,7 +128,7 @@ static inline int IMAX(int a, int b)
 int32_t opal_datatype_add(opal_datatype_t *pdtBase, const opal_datatype_t *pdtAdd, size_t count,
                           ptrdiff_t disp, ptrdiff_t extent)
 {
-    uint32_t newLength, place_needed = 0, i;
+    opal_datatype_count_t newLength, place_needed = 0, i;
     short localFlags = 0; /* no specific options yet */
     dt_elem_desc_t *pLast, *pLoop = NULL;
     ptrdiff_t lb, ub, true_lb, true_ub, epsilon, old_true_ub;
diff --git a/opal/datatype/opal_datatype_create.c b/opal/datatype/opal_datatype_create.c
index 536bdb6bd87..85dc317b348 100644
--- a/opal/datatype/opal_datatype_create.c
+++ b/opal/datatype/opal_datatype_create.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2009      Oak Ridge National Labs.  All rights reserved.
  * Copyright (c) 2019      Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
+ * Copyright (c) 2026      Stony Brook University.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -91,7 +92,7 @@ static void opal_datatype_destruct(opal_datatype_t *datatype)
 
 OBJ_CLASS_INSTANCE(opal_datatype_t, opal_object_t, opal_datatype_construct, opal_datatype_destruct);
 
-opal_datatype_t *opal_datatype_create(int32_t expectedSize)
+opal_datatype_t *opal_datatype_create(ssize_t expectedSize)
 {
     opal_datatype_t *datatype = (opal_datatype_t *) OBJ_NEW(opal_datatype_t);
 
@@ -107,7 +108,7 @@ opal_datatype_t *opal_datatype_create(int32_t expectedSize)
     return datatype;
 }
 
-int32_t opal_datatype_create_desc(opal_datatype_t *datatype, int32_t expectedSize)
+int32_t opal_datatype_create_desc(opal_datatype_t *datatype, ssize_t expectedSize)
 {
     if (expectedSize == -1) {
         expectedSize = DT_INCREASE_STACK;
diff --git a/opal/mca/accelerator/accelerator.h b/opal/mca/accelerator/accelerator.h
index 12f025f53c2..d035f3bc70b 100644
--- a/opal/mca/accelerator/accelerator.h
+++ b/opal/mca/accelerator/accelerator.h
@@ -8,6 +8,7 @@
  * Copyright (c) 2024      The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
+ * Copyright (c) 2026      NVIDIA Corporation.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -147,6 +148,17 @@ struct opal_accelerator_pci_attr_t {
 };
 typedef struct opal_accelerator_pci_attr_t opal_accelerator_pci_attr_t;
 
+#define OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN 16
+
+/*
+ * CUDA NVLink domain information used by OMPI_COMM_TYPE_NVLINK. Only the CUDA
+ * accelerator fills this structure.
+ */
+typedef struct {
+    int cuda_device;
+    uint8_t cluster_uuid[OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN];
+    uint32_t clique_id;
+} opal_accelerator_cuda_nvlink_domain_t;
 
 struct opal_accelerator_event_t {
     opal_object_t super;
diff --git a/opal/mca/accelerator/cuda/accelerator_cuda.c b/opal/mca/accelerator/cuda/accelerator_cuda.c
index 6a88d98df48..43a6f7acbb0 100644
--- a/opal/mca/accelerator/cuda/accelerator_cuda.c
+++ b/opal/mca/accelerator/cuda/accelerator_cuda.c
@@ -321,9 +321,6 @@ static int accelerator_cuda_check_addr(const void *addr, int *dev_id, uint64_t *
 
     *flags = 0;
 
-    is_vmm = accelerator_cuda_check_vmm(dbuf, &vmm_mem_type, &vmm_dev_id);
-    is_mpool_ptr = accelerator_cuda_check_mpool(dbuf, &mpool_mem_type, &mpool_dev_id);
-
 #if OPAL_CUDA_GET_ATTRIBUTES
     uint32_t is_managed = 0;
     /* With CUDA 7.0, we can get multiple attributes with a single call */
@@ -352,7 +349,20 @@ static int accelerator_cuda_check_addr(const void *addr, int *dev_id, uint64_t *
         } else {
             return OPAL_ERROR;
         }
-    } else if (CU_MEMORYTYPE_HOST == mem_type) {
+    }
+
+    if (CU_MEMORYTYPE_DEVICE == mem_type && NULL != mem_ctx) {
+        result = cuCtxGetCurrent(&ctx);
+        if (OPAL_UNLIKELY(NULL == ctx)) {
+            cuCtxSetCurrent(mem_ctx);
+        }
+        return 1;
+    }
+
+    is_vmm = accelerator_cuda_check_vmm(dbuf, &vmm_mem_type, &vmm_dev_id);
+    is_mpool_ptr = accelerator_cuda_check_mpool(dbuf, &mpool_mem_type, &mpool_dev_id);
+
+    if (CU_MEMORYTYPE_HOST == mem_type) {
         if (is_vmm && (vmm_mem_type == CU_MEMORYTYPE_DEVICE)) {
             mem_type = CU_MEMORYTYPE_DEVICE;
             *dev_id = vmm_dev_id;
@@ -377,6 +387,9 @@ static int accelerator_cuda_check_addr(const void *addr, int *dev_id, uint64_t *
         }
     }
 #else /* OPAL_CUDA_GET_ATTRIBUTES */
+    is_vmm = accelerator_cuda_check_vmm(dbuf, &vmm_mem_type, &vmm_dev_id);
+    is_mpool_ptr = accelerator_cuda_check_mpool(dbuf, &mpool_mem_type, &mpool_dev_id);
+
     result = cuPointerGetAttribute(&mem_type, CU_POINTER_ATTRIBUTE_MEMORY_TYPE, dbuf);
     if (CUDA_SUCCESS != result) {
         /* If cuda is not initialized, assume it is a host buffer. */
diff --git a/opal/mca/accelerator/cuda/accelerator_cuda_component.c b/opal/mca/accelerator/cuda/accelerator_cuda_component.c
index f7ffe8f3228..415aa6d30eb 100644
--- a/opal/mca/accelerator/cuda/accelerator_cuda_component.c
+++ b/opal/mca/accelerator/cuda/accelerator_cuda_component.c
@@ -6,7 +6,7 @@
  *                         reserved.
  * Copyright (c) 2017-2022 Amazon.com, Inc. or its affiliates.
  *                         All Rights reserved.
- * Copyright (c) 2024      NVIDIA Corporation.  All rights reserved.
+ * Copyright (c) 2024-2026 NVIDIA Corporation.  All rights reserved.
  * Copyright (c) 2024      The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
@@ -26,9 +26,15 @@
 #include "opal_config.h"
 
 #include <cuda.h>
+#include <nvml.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "accelerator_cuda.h"
 #include "opal/mca/accelerator/base/base.h"
+#include "opal/mca/base/mca_base_var.h"
 #include "opal/mca/dl/base/base.h"
 #include "opal/runtime/opal_params.h"
 #include "opal/util/argv.h"
@@ -47,9 +53,41 @@ bool mca_accelerator_cuda_init_complete = false;
 
 float *opal_accelerator_cuda_mem_bw = NULL;
 
+/*
+ * CUDA owns the NVLink domain cache. The MCA variable below is a read-only
+ * string mirror used by OMPI_COMM_TYPE_NVLINK, with
+ * opal_accelerator_nvlink_domain registered as a synonym so the communicator
+ * does not depend on a CUDA symbol.
+ */
+static opal_accelerator_cuda_nvlink_domain_t accelerator_cuda_nvlink_domain = {
+    .cuda_device = MCA_ACCELERATOR_NO_DEVICE_ID,
+};
+static char *accelerator_cuda_nvlink_domain_mca_string =
+    "cuda_device=-1,cluster_uuid=00000000000000000000000000000000,clique_id=0";
+static bool accelerator_cuda_nvlink_domain_mca_string_owned = false;
+
 #define STRINGIFY2(x) #x
 #define STRINGIFY(x)  STRINGIFY2(x)
 
+typedef nvmlReturn_t (*opal_cuda_nvmlInit_v2_fn_t)(void);
+typedef nvmlReturn_t (*opal_cuda_nvmlShutdown_fn_t)(void);
+typedef nvmlReturn_t (*opal_cuda_nvmlDeviceGetHandleByPciBusId_v2_fn_t)(
+    const char *pciBusId, nvmlDevice_t *device);
+typedef nvmlReturn_t (*opal_cuda_nvmlDeviceGetGpuFabricInfoV_fn_t)(
+    nvmlDevice_t device, nvmlGpuFabricInfoV_t *gpuFabricInfo);
+typedef nvmlReturn_t (*opal_cuda_nvmlDeviceGetNvLinkState_fn_t)(
+    nvmlDevice_t device, unsigned int link, nvmlEnableState_t *isActive);
+
+#define OPAL_CUDA_NVML_ASSIGN_FN(type, dst, sym) \
+    do {                                         \
+        union {                                  \
+            void *object;                        \
+            type function;                       \
+        } converter;                             \
+        converter.object = (sym);                \
+        *(dst) = converter.function;             \
+    } while (0)
+
 /* Unused variable that we register at init time and unregister at fini time.
  * This is used to detect if user has done a device reset prior to MPI_Finalize.
  * This is a workaround to avoid SEGVs.
@@ -71,6 +109,7 @@ static int accelerator_cuda_close(void);
 static int accelerator_cuda_component_register(void);
 static opal_accelerator_base_module_t* accelerator_cuda_init(void);
 static void accelerator_cuda_finalize(opal_accelerator_base_module_t* module);
+static int accelerator_cuda_cache_nvlink_domain(void);
 /*
  * Instantiate the public struct with all of our public information
  * and pointers to our public functions in it
@@ -123,6 +162,316 @@ static int accelerator_cuda_close(void)
 
 static int accelerator_cuda_component_register(void)
 {
+    int ret;
+
+    ret = mca_base_component_var_register(&mca_accelerator_cuda_component.super.base_version,
+                                          "nvlink_domain",
+                                          "Cached CUDA NVLink domain used by OMPI_COMM_TYPE_NVLINK",
+                                          MCA_BASE_VAR_TYPE_STRING, NULL, 0,
+                                          MCA_BASE_VAR_FLAG_DEFAULT_ONLY, OPAL_INFO_LVL_9,
+                                          MCA_BASE_VAR_SCOPE_READONLY,
+                                          &accelerator_cuda_nvlink_domain_mca_string);
+    if (0 > ret) {
+        return ret;
+    }
+    (void) mca_base_var_register_synonym(ret, "opal", "accelerator", NULL,
+                                         "nvlink_domain", 0);
+    accelerator_cuda_nvlink_domain_mca_string_owned = true;
+
+    return OPAL_SUCCESS;
+}
+
+static int accelerator_cuda_load_nvml(opal_dl_handle_t **handle,
+                                      opal_cuda_nvmlInit_v2_fn_t *dyn_nvml_init,
+                                      opal_cuda_nvmlShutdown_fn_t *dyn_nvml_shutdown,
+                                      opal_cuda_nvmlDeviceGetHandleByPciBusId_v2_fn_t
+                                          *dyn_nvml_device_get_handle_by_pci_bus_id,
+                                      opal_cuda_nvmlDeviceGetGpuFabricInfoV_fn_t
+                                          *dyn_nvml_device_get_gpu_fabric_info_v,
+                                      opal_cuda_nvmlDeviceGetNvLinkState_fn_t
+                                          *dyn_nvml_device_get_nvlink_state)
+{
+    const char *nvml_libraries[] = {"libnvidia-ml.so.1", "libnvidia-ml.so", NULL};
+    void *symbol;
+    char *err_msg = NULL;
+    int rc = OPAL_ERROR;
+
+    *handle = NULL;
+
+#if !OPAL_HAVE_DL_SUPPORT
+    return OPAL_ERR_NOT_AVAILABLE;
+#endif
+    if (NULL == opal_dl) {
+        return OPAL_ERR_NOT_AVAILABLE;
+    }
+
+    for (int i = 0; NULL != nvml_libraries[i]; ++i) {
+        rc = opal_dl_open(nvml_libraries[i], false, true, handle, &err_msg);
+        if (OPAL_SUCCESS == rc) {
+            break;
+        }
+    }
+
+    if (OPAL_SUCCESS != rc) {
+        return OPAL_ERR_NOT_AVAILABLE;
+    }
+
+    rc = opal_dl_lookup(*handle, "nvmlInit_v2", &symbol, NULL);
+    if (OPAL_SUCCESS != rc) {
+        goto error;
+    }
+    OPAL_CUDA_NVML_ASSIGN_FN(opal_cuda_nvmlInit_v2_fn_t, dyn_nvml_init, symbol);
+
+    rc = opal_dl_lookup(*handle, "nvmlShutdown", &symbol, NULL);
+    if (OPAL_SUCCESS != rc) {
+        goto error;
+    }
+    OPAL_CUDA_NVML_ASSIGN_FN(opal_cuda_nvmlShutdown_fn_t, dyn_nvml_shutdown, symbol);
+
+    rc = opal_dl_lookup(*handle, "nvmlDeviceGetHandleByPciBusId_v2", &symbol, NULL);
+    if (OPAL_SUCCESS != rc) {
+        goto error;
+    }
+    OPAL_CUDA_NVML_ASSIGN_FN(opal_cuda_nvmlDeviceGetHandleByPciBusId_v2_fn_t,
+                             dyn_nvml_device_get_handle_by_pci_bus_id, symbol);
+
+    rc = opal_dl_lookup(*handle, "nvmlDeviceGetGpuFabricInfoV", &symbol, NULL);
+    if (OPAL_SUCCESS != rc) {
+        goto error;
+    }
+    OPAL_CUDA_NVML_ASSIGN_FN(opal_cuda_nvmlDeviceGetGpuFabricInfoV_fn_t,
+                             dyn_nvml_device_get_gpu_fabric_info_v, symbol);
+
+    rc = opal_dl_lookup(*handle, "nvmlDeviceGetNvLinkState", &symbol, NULL);
+    if (OPAL_SUCCESS != rc) {
+        goto error;
+    }
+    OPAL_CUDA_NVML_ASSIGN_FN(opal_cuda_nvmlDeviceGetNvLinkState_fn_t,
+                             dyn_nvml_device_get_nvlink_state, symbol);
+
+    return OPAL_SUCCESS;
+
+error:
+    opal_dl_close(*handle);
+    *handle = NULL;
+    return OPAL_ERR_NOT_AVAILABLE;
+}
+
+static bool accelerator_cuda_nvlink_fabric_info_has_domain(const nvmlGpuFabricInfoV_t *fabric_info)
+{
+    return NVML_GPU_FABRIC_STATE_COMPLETED == fabric_info->state &&
+           NVML_SUCCESS == fabric_info->status;
+}
+
+static bool accelerator_cuda_nvlink_cluster_uuid_is_zero(const unsigned char *cluster_uuid)
+{
+    for (int i = 0; i < NVML_GPU_FABRIC_UUID_LEN; ++i) {
+        if (0 != cluster_uuid[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool accelerator_cuda_nvlink_has_active_link(
+    opal_cuda_nvmlDeviceGetNvLinkState_fn_t dyn_nvml_device_get_nvlink_state,
+    nvmlDevice_t nvml_device)
+{
+    for (unsigned int link = 0; link < NVML_NVLINK_MAX_LINKS; ++link) {
+        nvmlEnableState_t state;
+        nvmlReturn_t rc;
+
+        rc = dyn_nvml_device_get_nvlink_state(nvml_device, link, &state);
+        if (NVML_SUCCESS == rc && NVML_FEATURE_ENABLED == state) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static uint64_t accelerator_cuda_nvlink_hash_hostname(const char *hostname)
+{
+    uint64_t hash = 1469598103934665603ULL;
+
+    if (NULL == hostname) {
+        hostname = "unknown";
+    }
+
+    while ('\0' != *hostname) {
+        hash ^= (uint8_t) *hostname++;
+        hash *= 1099511628211ULL;
+    }
+
+    return hash;
+}
+
+static void accelerator_cuda_nvlink_make_single_node_uuid(unsigned char *uuid,
+                                                          const char *hostname)
+{
+    /* Encode an active single-node NVLink domain reported by NVML with an
+     * all-zero cluster UUID. OMPI_COMM_TYPE_NVLINK does not synthesize this
+     * token; CUDA is the only producer of the node-local NVLink encoding. */
+    static const unsigned char signature[8] = {'O', 'M', 'P', 'I',
+                                               'N', 'V', 'L', '0'};
+    uint64_t hash = accelerator_cuda_nvlink_hash_hostname(hostname);
+
+    for (int i = 0; i < 8; ++i) {
+        uuid[i] = (hash >> (56 - i * 8)) & 0xff;
+    }
+    memcpy(uuid + 8, signature, sizeof(signature));
+}
+
+static void accelerator_cuda_nvlink_domain_uuid_to_hex(
+    const uint8_t uuid[OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN],
+    char hex_uuid[2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN + 1])
+{
+    static const char hex[] = "0123456789abcdef";
+
+    for (int i = 0; i < OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN; ++i) {
+        hex_uuid[2 * i] = hex[uuid[i] >> 4];
+        hex_uuid[2 * i + 1] = hex[uuid[i] & 0x0f];
+    }
+    hex_uuid[2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN] = '\0';
+}
+
+static int accelerator_cuda_update_nvlink_domain_mca_string(void)
+{
+    char hex_uuid[2 * OPAL_ACCELERATOR_NVLINK_CLUSTER_UUID_LEN + 1];
+    char value[128];
+    char *new_value;
+    int written;
+
+    accelerator_cuda_nvlink_domain_uuid_to_hex(accelerator_cuda_nvlink_domain.cluster_uuid,
+                                               hex_uuid);
+    written = snprintf(value, sizeof(value), "cuda_device=%d,cluster_uuid=%s,clique_id=%u",
+                       accelerator_cuda_nvlink_domain.cuda_device, hex_uuid,
+                       accelerator_cuda_nvlink_domain.clique_id);
+    if (0 > written || sizeof(value) <= (size_t) written) {
+        return OPAL_ERROR;
+    }
+
+    new_value = strdup(value);
+    if (NULL == new_value) {
+        return OPAL_ERR_OUT_OF_RESOURCE;
+    }
+
+    if (accelerator_cuda_nvlink_domain_mca_string_owned) {
+        free(accelerator_cuda_nvlink_domain_mca_string);
+    }
+    accelerator_cuda_nvlink_domain_mca_string = new_value;
+    accelerator_cuda_nvlink_domain_mca_string_owned = true;
+
+    return OPAL_SUCCESS;
+}
+
+static nvmlReturn_t accelerator_cuda_get_gpu_fabric_info(
+    opal_cuda_nvmlDeviceGetGpuFabricInfoV_fn_t dyn_nvml_device_get_gpu_fabric_info_v,
+    nvmlDevice_t nvml_device, nvmlGpuFabricInfoV_t *fabric_info)
+{
+    nvmlReturn_t rc;
+
+#if defined(nvmlGpuFabricInfo_v3)
+    memset(fabric_info, 0, sizeof(*fabric_info));
+    fabric_info->version = nvmlGpuFabricInfo_v3;
+    rc = dyn_nvml_device_get_gpu_fabric_info_v(nvml_device, fabric_info);
+    if (NVML_SUCCESS == rc && accelerator_cuda_nvlink_fabric_info_has_domain(fabric_info)) {
+        return NVML_SUCCESS;
+    }
+#endif
+
+    memset(fabric_info, 0, sizeof(*fabric_info));
+    fabric_info->version = nvmlGpuFabricInfo_v2;
+    return dyn_nvml_device_get_gpu_fabric_info_v(nvml_device, fabric_info);
+}
+
+static int accelerator_cuda_cache_nvlink_domain(void)
+{
+    opal_cuda_nvmlDeviceGetGpuFabricInfoV_fn_t dyn_nvml_device_get_gpu_fabric_info_v;
+    opal_cuda_nvmlDeviceGetHandleByPciBusId_v2_fn_t dyn_nvml_device_get_handle_by_pci_bus_id;
+    opal_cuda_nvmlDeviceGetNvLinkState_fn_t dyn_nvml_device_get_nvlink_state;
+    nvmlGpuFabricInfoV_t fabric_info;
+    opal_accelerator_cuda_nvlink_domain_t domain = {
+        .cuda_device = MCA_ACCELERATOR_NO_DEVICE_ID,
+    };
+    opal_cuda_nvmlShutdown_fn_t dyn_nvml_shutdown;
+    nvmlDevice_t nvml_device;
+    opal_cuda_nvmlInit_v2_fn_t dyn_nvml_init;
+    opal_dl_handle_t *nvml_handle = NULL;
+    char pci_bus_id[16] = {0};
+    CUdevice cuDevice;
+    CUresult cu_rc;
+    nvmlReturn_t nvml_rc;
+    int rc;
+
+    accelerator_cuda_nvlink_domain = domain;
+    (void) accelerator_cuda_update_nvlink_domain_mca_string();
+
+    cu_rc = cuCtxGetDevice(&cuDevice);
+    if (CUDA_SUCCESS != cu_rc) {
+        return OPAL_ERR_NOT_AVAILABLE;
+    }
+
+    cu_rc = cuDeviceGetPCIBusId(pci_bus_id, sizeof(pci_bus_id), cuDevice);
+    if (CUDA_SUCCESS != cu_rc) {
+        return OPAL_ERR_NOT_AVAILABLE;
+    }
+
+    rc = accelerator_cuda_load_nvml(&nvml_handle, &dyn_nvml_init, &dyn_nvml_shutdown,
+                                    &dyn_nvml_device_get_handle_by_pci_bus_id,
+                                    &dyn_nvml_device_get_gpu_fabric_info_v,
+                                    &dyn_nvml_device_get_nvlink_state);
+    if (OPAL_SUCCESS != rc) {
+        return rc;
+    }
+
+    nvml_rc = dyn_nvml_init();
+    if (NVML_SUCCESS != nvml_rc) {
+        goto out;
+    }
+
+    nvml_rc = dyn_nvml_device_get_handle_by_pci_bus_id(pci_bus_id, &nvml_device);
+    if (NVML_SUCCESS != nvml_rc) {
+        goto shutdown;
+    }
+
+    if (!accelerator_cuda_nvlink_has_active_link(dyn_nvml_device_get_nvlink_state,
+                                                 nvml_device)) {
+        goto shutdown;
+    }
+
+    nvml_rc = accelerator_cuda_get_gpu_fabric_info(dyn_nvml_device_get_gpu_fabric_info_v,
+                                                   nvml_device, &fabric_info);
+    if (NVML_SUCCESS != nvml_rc ||
+        !accelerator_cuda_nvlink_fabric_info_has_domain(&fabric_info)) {
+        goto shutdown;
+    }
+
+    domain.cuda_device = (int) cuDevice;
+    if (accelerator_cuda_nvlink_cluster_uuid_is_zero(fabric_info.clusterUuid)) {
+        /* NVML reports an all-zero cluster UUID for single-node NVLink domains.
+         * Store a nonzero hostname-derived token only from the CUDA component,
+         * so the MCA default can remain all zero without suggesting a
+         * node-local NVLink domain. In this case, use the CUDA device ordinal
+         * as the split key. */
+        domain.clique_id = (uint32_t) cuDevice;
+        accelerator_cuda_nvlink_make_single_node_uuid(domain.cluster_uuid,
+                                                      OPAL_PROC_MY_HOSTNAME);
+    } else {
+        /* Multi-node/fabric domains provide a real nonzero clusterUuid and a
+         * cliqueId, which become the split color token and key respectively. */
+        domain.clique_id = fabric_info.cliqueId;
+        memcpy(domain.cluster_uuid, fabric_info.clusterUuid, sizeof(domain.cluster_uuid));
+    }
+
+    accelerator_cuda_nvlink_domain = domain;
+    (void) accelerator_cuda_update_nvlink_domain_mca_string();
+
+shutdown:
+    dyn_nvml_shutdown();
+out:
+    opal_dl_close(nvml_handle);
     return OPAL_SUCCESS;
 }
 
@@ -187,6 +536,7 @@ int opal_accelerator_cuda_delayed_init()
 
     } else {
         opal_output_verbose(20, opal_accelerator_base_framework.framework_output, "CUDA: cuCtxGetCurrent succeeded");
+        (void) accelerator_cuda_cache_nvlink_domain();
     }
 
     /* Create stream for use in cuMemcpyAsync synchronous copies */
diff --git a/opal/mca/accelerator/rocm/accelerator_rocm_module.c b/opal/mca/accelerator/rocm/accelerator_rocm_module.c
index 1419eeedcfe..056b4de3542 100644
--- a/opal/mca/accelerator/rocm/accelerator_rocm_module.c
+++ b/opal/mca/accelerator/rocm/accelerator_rocm_module.c
@@ -352,7 +352,7 @@ static int mca_accelerator_rocm_memcpy(int dest_dev_id, int src_dev_id, void *de
 {
     hipError_t err;
 
-    if (NULL == src || NULL == dest || size < 0) {
+    if (NULL == src || NULL == dest) {
         return OPAL_ERR_BAD_PARAM;
     }
     if (0 == size) {
@@ -652,8 +652,8 @@ static int mca_accelerator_rocm_compare_ipc_handles(uint8_t handle_1[IPC_MAX_HAN
      * and the process ID for comparison.
      * We definitily need to exclude the offset component in the comparison.
      */
-    static const int rocr_ipc_handle_size = 32;
-    static const int pos = rocr_ipc_handle_size + 2*sizeof(size_t);
+    const int rocr_ipc_handle_size = 32;
+    const int pos = rocr_ipc_handle_size + 2*sizeof(size_t);
     int *pid_1 = (int *)&handle_1[pos];
     int *pid_2 = (int *)&handle_2[pos];
 
diff --git a/opal/mca/base/mca_base_component_repository.c b/opal/mca/base/mca_base_component_repository.c
index f359cfa9019..b4a8e502b76 100644
--- a/opal/mca/base/mca_base_component_repository.c
+++ b/opal/mca/base/mca_base_component_repository.c
@@ -296,7 +296,7 @@ static void mca_base_component_repository_release_internal(mca_base_component_re
 {
     int group_id;
 
-    group_id = mca_base_var_group_find(NULL, ri->ri_type, ri->ri_name);
+    group_id = mca_base_var_group_find("*", ri->ri_type, ri->ri_name);
     if (0 <= group_id) {
         /* ensure all variables are deregistered before we dlclose the component */
         mca_base_var_group_deregister(group_id);
diff --git a/opal/mca/base/mca_base_var_group.c b/opal/mca/base/mca_base_var_group.c
index 732df663e98..559893cf7e4 100644
--- a/opal/mca/base/mca_base_var_group.c
+++ b/opal/mca/base/mca_base_var_group.c
@@ -28,6 +28,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <assert.h>
 #include <string.h>
 #ifdef HAVE_UNISTD_H
 #    include <unistd.h>
@@ -395,6 +396,7 @@ int mca_base_var_group_deregister(int group_index)
 int mca_base_var_group_find(const char *project_name, const char *framework_name,
                             const char *component_name)
 {
+    assert(NULL != project_name);
     return group_find(project_name, framework_name, component_name, false);
 }
 
diff --git a/opal/mca/btl/ofi/btl_ofi.h b/opal/mca/btl/ofi/btl_ofi.h
index 20345d02c6b..085eee27471 100644
--- a/opal/mca/btl/ofi/btl_ofi.h
+++ b/opal/mca/btl/ofi/btl_ofi.h
@@ -80,7 +80,9 @@ enum mca_btl_ofi_hdr_type {
     MCA_BTL_OFI_TYPE_TOTAL
 };
 
+struct mca_btl_ofi_module_t;
 struct mca_btl_ofi_context_t {
+    struct mca_btl_ofi_module_t *btl;
     int32_t context_id;
 
     /* transmit context */
diff --git a/opal/mca/btl/ofi/btl_ofi_component.c b/opal/mca/btl/ofi/btl_ofi_component.c
index 3f1e277dd69..744faa27fcc 100644
--- a/opal/mca/btl/ofi/btl_ofi_component.c
+++ b/opal/mca/btl/ofi/btl_ofi_component.c
@@ -625,7 +625,7 @@ static int mca_btl_ofi_init_device(struct fi_info *info)
 
         /* create contexts */
         module->contexts = mca_btl_ofi_context_alloc_scalable(ofi_info, domain, ep, av,
-                                                              num_contexts_to_create);
+                                                              module, num_contexts_to_create);
 
     } else {
         /* warn the user if they want more than 1 context */
@@ -647,7 +647,7 @@ static int mca_btl_ofi_init_device(struct fi_info *info)
         module->is_scalable_ep = false;
 
         /* create contexts */
-        module->contexts = mca_btl_ofi_context_alloc_normal(ofi_info, domain, ep, av);
+        module->contexts = mca_btl_ofi_context_alloc_normal(ofi_info, domain, ep, av, module);
     }
 
     if (NULL == module->contexts) {
diff --git a/opal/mca/btl/ofi/btl_ofi_context.c b/opal/mca/btl/ofi/btl_ofi_context.c
index ea876d548c0..8bc3edd302c 100644
--- a/opal/mca/btl/ofi/btl_ofi_context.c
+++ b/opal/mca/btl/ofi/btl_ofi_context.c
@@ -62,7 +62,8 @@ static int init_context_freelists(mca_btl_ofi_context_t *context)
  * USE WITH NORMAL ENDPOINT ONLY */
 mca_btl_ofi_context_t *mca_btl_ofi_context_alloc_normal(struct fi_info *info,
                                                         struct fid_domain *domain,
-                                                        struct fid_ep *ep, struct fid_av *av)
+                                                        struct fid_ep *ep, struct fid_av *av,
+                                                        struct mca_btl_ofi_module_t *btl)
 {
     int rc;
     uint32_t cq_flags = FI_TRANSMIT | FI_SEND | FI_RECV;
@@ -115,6 +116,7 @@ mca_btl_ofi_context_t *mca_btl_ofi_context_alloc_normal(struct fi_info *info,
     context->tx_ctx = ep;
     context->rx_ctx = ep;
     context->context_id = 0;
+    context->btl = btl;
     my_context = NULL;
 
     return context;
@@ -132,6 +134,7 @@ mca_btl_ofi_context_t *mca_btl_ofi_context_alloc_normal(struct fi_info *info,
 mca_btl_ofi_context_t *mca_btl_ofi_context_alloc_scalable(struct fi_info *info,
                                                           struct fid_domain *domain,
                                                           struct fid_ep *sep, struct fid_av *av,
+                                                          struct mca_btl_ofi_module_t* btl,
                                                           size_t num_contexts)
 {
     BTL_VERBOSE(("creating %zu contexts", num_contexts));
@@ -234,6 +237,7 @@ mca_btl_ofi_context_t *mca_btl_ofi_context_alloc_scalable(struct fi_info *info,
 
         /* assign the id */
         contexts[i].context_id = i;
+        contexts[i].btl = btl;
     }
 
     return contexts;
@@ -387,26 +391,60 @@ int mca_btl_ofi_context_progress(mca_btl_ofi_context_t *context)
             BTL_ERROR(("%s:%d: Error returned from fi_cq_readerr: %s(%d)", __FILE__, __LINE__,
                        fi_strerror(-ret), ret));
             MCA_BTL_OFI_ABORT();
-        } else if(NULL != cqerr.op_context){
+        } else {
             switch(cqerr.err) {
-            case -FI_EIO: {
-                mca_btl_ofi_completion_context_t *c_ctx =
-                    (mca_btl_ofi_completion_context_t*) cqerr.op_context;
-                mca_btl_ofi_base_completion_t *comp =
-                    (mca_btl_ofi_base_completion_t*) c_ctx->comp;
-                mca_btl_ofi_module_t *ofi_btl =
-                    (mca_btl_ofi_module_t*) comp->btl;
-                if(ofi_btl->ofi_error_cb){
-                    opal_proc_t *ep_proc = NULL;
-                    if(comp->endpoint){
-                        ep_proc = comp->endpoint->ep_proc;
+            case FI_EREMOTEIO:
+            case FI_EHOSTUNREACH:
+            case FI_ECONNABORTED:
+            case FI_ECONNRESET:
+            case FI_ENOTCONN:
+#ifdef FI_EHOSTDOWN
+            // FI_EHOSTDOWN added in libfabric 1.6.0
+            case FI_EHOSTDOWN:
+#endif
+            case FI_EIO: {
+                if (context->btl->ofi_error_cb) {
+                    opal_proc_t* proc = NULL;
+                    if (NULL != cqerr.op_context) {
+                        mca_btl_ofi_completion_context_t *c_ctx =
+                            (mca_btl_ofi_completion_context_t*) cqerr.op_context;
+                        mca_btl_ofi_base_completion_t *comp =
+                            (mca_btl_ofi_base_completion_t*) c_ctx->comp;
+                        if (NULL != comp->endpoint) {
+                            proc = comp->endpoint->ep_proc;
+                        }
+                    }
+#if (FI_MAJOR_VERSION > 1) || ((FI_MAJOR_VERSION > 0) && (FI_MINOR_VERSION >= 20))
+                    // Starting with v1.20, cqerr provides an fi_addr_t
+                    if (NULL == proc) {
+                        mca_btl_ofi_endpoint_t *ep = NULL;
+                        OPAL_LIST_FOREACH(ep, &context->btl->endpoints, mca_btl_ofi_endpoint_t){
+                            if (ep->peer_addr == cqerr.src_addr) {
+                                proc = ep->ep_proc;
+                                break;
+                            }
+                        }
+                    }
+#endif
+                    const char* base_str = "IO error reported by libfabric: ";
+                    const char* fi_str = fi_strerror(cqerr.err);
+                    size_t base_len = strlen(base_str);
+                    size_t fi_len = strlen(fi_str);
+                    char* err_str = malloc(base_len + fi_len + 1);
+                    for(size_t i = 0; i < base_len; i++) err_str[i] = base_str[i];
+                    for(size_t i = 0; i < fi_len; i++) err_str[i+base_len] = fi_str[i];
+                    err_str[base_len+fi_len] = '\0';
+                    if (cqerr.op_context || proc) {
+                        // Report any errors linked to an operation or known proc
+                        context->btl->ofi_error_cb(&context->btl->super, 0, proc, err_str);
                     }
-                    ofi_btl->ofi_error_cb(comp->btl, 0, ep_proc,
-                        "IO error reported by libfabric");
+                    free(err_str);
                 }
 
-                ++events;
-                complete_op_context(context, cqerr.op_context, OPAL_ERR_UNREACH);
+                if (NULL != cqerr.op_context) {
+                    ++events;
+                    complete_op_context(context, cqerr.op_context, OPAL_ERR_UNREACH);
+                }
                 break;
             }
             default:
diff --git a/opal/mca/btl/ofi/btl_ofi_endpoint.h b/opal/mca/btl/ofi/btl_ofi_endpoint.h
index f6b420273af..088330fe04f 100644
--- a/opal/mca/btl/ofi/btl_ofi_endpoint.h
+++ b/opal/mca/btl/ofi/btl_ofi_endpoint.h
@@ -57,11 +57,13 @@ mca_btl_base_endpoint_t *mca_btl_ofi_endpoint_create(opal_proc_t *proc, struct f
 mca_btl_ofi_context_t *mca_btl_ofi_context_alloc_scalable(struct fi_info *info,
                                                           struct fid_domain *domain,
                                                           struct fid_ep *sep, struct fid_av *av,
+                                                          struct mca_btl_ofi_module_t *btl,
                                                           size_t num_contexts);
 
 mca_btl_ofi_context_t *mca_btl_ofi_context_alloc_normal(struct fi_info *info,
                                                         struct fid_domain *domain,
-                                                        struct fid_ep *ep, struct fid_av *av);
+                                                        struct fid_ep *ep, struct fid_av *av,
+                                                        struct mca_btl_ofi_module_t *btl);
 void mca_btl_ofi_context_finalize(mca_btl_ofi_context_t *context, bool scalable_ep);
 
 mca_btl_ofi_context_t *get_ofi_context(mca_btl_ofi_module_t *btl);
diff --git a/opal/mca/btl/ofi/btl_ofi_frag.c b/opal/mca/btl/ofi/btl_ofi_frag.c
index e325dd34ccf..cb51da4a74f 100644
--- a/opal/mca/btl/ofi/btl_ofi_frag.c
+++ b/opal/mca/btl/ofi/btl_ofi_frag.c
@@ -44,6 +44,7 @@ mca_btl_ofi_frag_completion_t *mca_btl_ofi_frag_completion_alloc(mca_btl_base_mo
 
     comp = (mca_btl_ofi_frag_completion_t *) opal_free_list_get(&context->frag_comp_list);
     comp->base.btl = btl;
+    comp->base.endpoint = frag->endpoint;
     comp->base.my_context = context;
     comp->base.my_list = &context->frag_comp_list;
     comp->base.type = type;
@@ -158,8 +159,10 @@ int mca_btl_ofi_recv_frag(mca_btl_ofi_module_t *ofi_btl, mca_btl_base_endpoint_t
                                                    .tag = frag->hdr.tag,
                                                    .cbdata = reg->cbdata};
 
-    /* call the callback */
-    reg->cbfunc(&ofi_btl->super, &recv_desc);
+    if (OPAL_LIKELY(OPAL_SUCCESS == rc)) {
+        /* call the callback */
+        reg->cbfunc(&ofi_btl->super, &recv_desc);
+    }
     mca_btl_ofi_frag_complete(frag, rc);
 
     /* repost the recv */
diff --git a/opal/mca/btl/self/btl_self.c b/opal/mca/btl/self/btl_self.c
index 1790d576780..f7ed1f9a49e 100644
--- a/opal/mca/btl/self/btl_self.c
+++ b/opal/mca/btl/self/btl_self.c
@@ -32,8 +32,57 @@
 #include "btl_self_frag.h"
 #include "opal/class/opal_bitmap.h"
 #include "opal/datatype/opal_convertor.h"
+#include "opal/mca/accelerator/accelerator.h"
+#include "opal/mca/accelerator/base/base.h"
+#include "opal/mca/btl/base/btl_base_error.h"
 #include "opal/util/proc.h"
 
+/**
+ * Accelerator-aware memory copy. Checks whether src and/or dst reside
+ * in accelerator memory and dispatches to opal_accelerator.mem_copy()
+ * accordingly. Falls back to a regular memcpy() when both buffers are in
+ * host memory.
+ *
+ * @param dst (IN) Destination buffer (host or device memory)
+ * @param src (IN) Source buffer (host or device memory)
+ * @param size (IN) Number of bytes to copy
+ * @return     OPAL_SUCCESS or error status on failure.
+ */
+static int mca_btl_self_memcpy(void *dst, const void *src, size_t size)
+{
+    int dst_dev = MCA_ACCELERATOR_NO_DEVICE_ID;
+    int src_dev = MCA_ACCELERATOR_NO_DEVICE_ID;
+    int dst_type, src_type;
+    int copy_type = MCA_ACCELERATOR_TRANSFER_DTOD;
+    uint64_t flags;
+    int rc;
+
+    dst_type = opal_accelerator.check_addr(dst, &dst_dev, &flags);
+    src_type = opal_accelerator.check_addr(src, &src_dev, &flags);
+
+    if (dst_type < 0 || src_type < 0) {
+        BTL_ERROR(("check_addr failed (dst_type=%d, src_type=%d)", dst_type, src_type));
+        return OPAL_ERROR;
+    }
+
+    if (0 == dst_type && 0 == src_type) {
+        memcpy(dst, src, size);
+        return OPAL_SUCCESS;
+    } else if (dst_type == 0 && src_type > 0) {
+        copy_type = MCA_ACCELERATOR_TRANSFER_DTOH;
+        dst_dev = MCA_ACCELERATOR_NO_DEVICE_ID;
+    } else if (dst_type > 0 && src_type == 0) {
+        copy_type = MCA_ACCELERATOR_TRANSFER_HTOD;
+        src_dev = MCA_ACCELERATOR_NO_DEVICE_ID;
+    }
+
+    rc = opal_accelerator.mem_copy(dst_dev, src_dev, dst, src, size, copy_type);
+    if (OPAL_UNLIKELY(OPAL_SUCCESS != rc)) {
+        BTL_ERROR(("accelerator mem_copy failed (rc=%d)", rc));
+    }
+    return rc;
+}
+
 /**
  * PML->BTL notification of change in the process list.
  * PML->BTL Notification that a receive fragment has been matched.
@@ -268,9 +317,9 @@ static int mca_btl_self_put(mca_btl_base_module_t *btl, struct mca_btl_base_endp
                             int flags, int order, mca_btl_base_rdma_completion_fn_t cbfunc,
                             void *cbcontext, void *cbdata)
 {
-    memcpy((void *) (intptr_t) remote_address, local_address, size);
+    int rc = mca_btl_self_memcpy((void *) (intptr_t) remote_address, local_address, size);
 
-    cbfunc(btl, endpoint, local_address, NULL, cbcontext, cbdata, OPAL_SUCCESS);
+    cbfunc(btl, endpoint, local_address, NULL, cbcontext, cbdata, rc);
 
     return OPAL_SUCCESS;
 }
@@ -282,9 +331,9 @@ static int mca_btl_self_get(mca_btl_base_module_t *btl, struct mca_btl_base_endp
                             int flags, int order, mca_btl_base_rdma_completion_fn_t cbfunc,
                             void *cbcontext, void *cbdata)
 {
-    memcpy(local_address, (void *) (intptr_t) remote_address, size);
+    int rc = mca_btl_self_memcpy(local_address, (void *) (intptr_t) remote_address, size);
 
-    cbfunc(btl, endpoint, local_address, NULL, cbcontext, cbdata, OPAL_SUCCESS);
+    cbfunc(btl, endpoint, local_address, NULL, cbcontext, cbdata, rc);
 
     return OPAL_SUCCESS;
 }
diff --git a/opal/mca/btl/self/btl_self_component.c b/opal/mca/btl/self/btl_self_component.c
index 4fc78e6abb8..109afba5271 100644
--- a/opal/mca/btl/self/btl_self_component.c
+++ b/opal/mca/btl/self/btl_self_component.c
@@ -110,6 +110,8 @@ static int mca_btl_self_component_register(void)
     mca_btl_self.btl_flags = MCA_BTL_FLAGS_RDMA | MCA_BTL_FLAGS_SEND_INPLACE | MCA_BTL_FLAGS_SEND;
     /* for self, remote completion is local completion */
     mca_btl_self.btl_flags |= MCA_BTL_FLAGS_RDMA_REMOTE_COMPLETION;
+    /* put/get go directly to/from accelerator memory, no host staging */
+    mca_btl_self.btl_flags |= MCA_BTL_FLAGS_ACCELERATOR_RDMA;
     mca_btl_self.btl_bandwidth = 100;
     mca_btl_self.btl_latency = 0;
     mca_btl_base_param_register(&mca_btl_self_component.super.btl_version, &mca_btl_self);
diff --git a/opal/mca/btl/sm/btl_sm_module.c b/opal/mca/btl/sm/btl_sm_module.c
index ebf7aaaaecf..7c92537e08e 100644
--- a/opal/mca/btl/sm/btl_sm_module.c
+++ b/opal/mca/btl/sm/btl_sm_module.c
@@ -186,13 +186,32 @@ static int init_sm_endpoint(struct mca_btl_base_endpoint_t **ep_out, struct opal
             mca_btl_sm.super.btl_put = NULL;
             mca_btl_sm.super.btl_flags &= ~MCA_BTL_FLAGS_RDMA;
         }
-            /* store a copy of the segment information for detach */
-            ep->seg_ds = malloc(modex->seg_ds_size);
+            /* Validate the peer-supplied descriptor length before trusting it.
+             * The modex must actually contain seg_ds_size bytes of seg_ds, and
+             * that length must fit in opal_shmem_ds_t. */
+            const size_t modex_hdr_size = sizeof(*modex) - sizeof(modex->seg_ds);
+            if (modex->seg_ds_size <= 0
+                || (size_t) modex->seg_ds_size > sizeof(opal_shmem_ds_t)
+                || msg_size < modex_hdr_size
+                || (size_t) modex->seg_ds_size > msg_size - modex_hdr_size) {
+                free(modex);
+                return OPAL_ERR_BAD_PARAM;
+            }
+
+            /* Always allocate the full struct so later consumers (detach,
+             * opal_shmem_sizeof_shmem_ds) cannot read or write past the end
+             * of the heap object. */
+            ep->seg_ds = calloc(1, sizeof(opal_shmem_ds_t));
             if (NULL == ep->seg_ds) {
+                free(modex);
                 return OPAL_ERR_OUT_OF_RESOURCE;
             }
 
             memcpy(ep->seg_ds, &modex->seg_ds, modex->seg_ds_size);
+            /* Guarantee seg_name is NUL-terminated even if the peer sent an
+             * unterminated path, so opal_shmem_sizeof_shmem_ds()'s strlen
+             * cannot run past the buffer. */
+            ep->seg_ds->seg_name[OPAL_PATH_MAX - 1] = '\0';
 
             ep->segment_base = opal_shmem_segment_attach(ep->seg_ds);
             if (NULL == ep->segment_base) {
@@ -514,17 +533,11 @@ static void mca_btl_sm_endpoint_destructor(mca_btl_sm_endpoint_t *ep)
     OBJ_DESTRUCT(&ep->pending_frags_lock);
 
     if (ep->seg_ds) {
-        opal_shmem_ds_t seg_ds;
-
-        /* opal_shmem_segment_detach expects a opal_shmem_ds_t and will
-         * stomp past the end of the seg_ds if it is too small (which
-         * ep->seg_ds probably is) */
-        memcpy(&seg_ds, ep->seg_ds, opal_shmem_sizeof_shmem_ds(ep->seg_ds));
+        /* ep->seg_ds is allocated full-size in init_sm_endpoint, so detach
+         * cannot read or write past the end of it. */
+        opal_shmem_segment_detach(ep->seg_ds);
         free(ep->seg_ds);
         ep->seg_ds = NULL;
-
-        /* disconnect from the peer's segment */
-        opal_shmem_segment_detach(&seg_ds);
     }
 
     if (ep->fbox_out.fbox) {
diff --git a/opal/mca/btl/tcp/btl_tcp_endpoint.c b/opal/mca/btl/tcp/btl_tcp_endpoint.c
index fb2a5212993..7a7ec64f4da 100644
--- a/opal/mca/btl/tcp/btl_tcp_endpoint.c
+++ b/opal/mca/btl/tcp/btl_tcp_endpoint.c
@@ -168,7 +168,11 @@ void mca_btl_tcp_endpoint_dump(int level, const char *fname, int lineno, const c
         }
     }
 #    else
-    used += snprintf(&outmsg[used], DEBUG_LENGTH - used, "%s -", inet_ntoa(inaddr.sin_addr));
+    {
+        char ep_addr[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &inaddr.sin_addr, ep_addr, sizeof(ep_addr));
+        used += snprintf(&outmsg[used], DEBUG_LENGTH - used, "%s -", ep_addr);
+    }
     if (used >= DEBUG_LENGTH)
         goto out;
 #    endif
@@ -184,7 +188,11 @@ void mca_btl_tcp_endpoint_dump(int level, const char *fname, int lineno, const c
         }
     }
 #    else
-    used += snprintf(&outmsg[used], DEBUG_LENGTH - used, " %s", inet_ntoa(inaddr.sin_addr));
+    {
+        char ep_addr[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &inaddr.sin_addr, ep_addr, sizeof(ep_addr));
+        used += snprintf(&outmsg[used], DEBUG_LENGTH - used, " %s", ep_addr);
+    }
     if (used >= DEBUG_LENGTH)
         goto out;
 #    endif
diff --git a/opal/mca/btl/uct/btl_uct_component.c b/opal/mca/btl/uct/btl_uct_component.c
index 7c5999facad..ef00b84b478 100644
--- a/opal/mca/btl/uct/btl_uct_component.c
+++ b/opal/mca/btl/uct/btl_uct_component.c
@@ -146,23 +146,6 @@ static int mca_btl_uct_component_register(void)
         MCA_BASE_VAR_TYPE_UNSIGNED_INT, NULL, 0, MCA_BASE_VAR_FLAG_SETTABLE, OPAL_INFO_LVL_4,
         MCA_BASE_VAR_SCOPE_LOCAL, &mca_btl_uct_component.connection_retry_timeout);
 
-    OBJ_CONSTRUCT(&mca_btl_uct_component.md_list, opal_list_t);
-    OBJ_CONSTRUCT(&mca_btl_uct_component.memory_domain_list, mca_btl_uct_include_list_t);
-    OBJ_CONSTRUCT(&mca_btl_uct_component.connection_domain_list, mca_btl_uct_include_list_t);
-
-    int rc = mca_btl_uct_component_discover_mds();
-    if (OPAL_SUCCESS != rc) {
-        return rc;
-    }
-
-    rc = mca_btl_uct_component_generate_modules(&mca_btl_uct_component.md_list);
-    if (OPAL_SUCCESS != rc) {
-        return rc;
-    }
-
-    mca_btl_uct_component.initialized = true;
-    opal_finalize_register_cleanup(mca_btl_uct_cleanup);
-
     return OPAL_SUCCESS;
 }
 
@@ -206,6 +189,22 @@ static int mca_btl_uct_component_open(void)
         opal_mem_hooks_register_release(mca_btl_uct_mem_release_cb, NULL);
     }
 
+    OBJ_CONSTRUCT(&mca_btl_uct_component.md_list, opal_list_t);
+    OBJ_CONSTRUCT(&mca_btl_uct_component.memory_domain_list, mca_btl_uct_include_list_t);
+    OBJ_CONSTRUCT(&mca_btl_uct_component.connection_domain_list, mca_btl_uct_include_list_t);
+
+    int rc = mca_btl_uct_component_discover_mds();
+    if (OPAL_SUCCESS != rc) {
+        return rc;
+    }
+
+    rc = mca_btl_uct_component_generate_modules(&mca_btl_uct_component.md_list);
+    if (OPAL_SUCCESS != rc) {
+        return rc;
+    }
+
+    mca_btl_uct_component.initialized = true;
+
     return OPAL_SUCCESS;
 }
 
diff --git a/opal/mca/btl/uct/btl_uct_module.c b/opal/mca/btl/uct/btl_uct_module.c
index e847a45623f..f6c99a46cd0 100644
--- a/opal/mca/btl/uct/btl_uct_module.c
+++ b/opal/mca/btl/uct/btl_uct_module.c
@@ -356,6 +356,7 @@ mca_btl_uct_module_t mca_btl_uct_module_template = {
         .btl_finalize = mca_btl_uct_finalize,
         .btl_put = mca_btl_uct_put,
         .btl_get = mca_btl_uct_get,
+        .btl_dump = mca_btl_base_dump,
         .btl_register_mem = mca_btl_uct_register_mem,
         .btl_deregister_mem = mca_btl_uct_deregister_mem,
         .btl_atomic_op = mca_btl_uct_aop,
diff --git a/opal/mca/btl/usnic/btl_usnic_module.c b/opal/mca/btl/usnic/btl_usnic_module.c
index 7ae08e6fb67..63fa1351305 100644
--- a/opal/mca/btl/usnic/btl_usnic_module.c
+++ b/opal/mca/btl/usnic/btl_usnic_module.c
@@ -1564,10 +1564,14 @@ static int create_ep(opal_btl_usnic_module_t *module, struct opal_btl_usnic_chan
     } else {
         str = "UNKNOWN";
     }
-    opal_output_verbose(15, USNIC_OUT,
-                        "btl:usnic:create_ep:%s: new usnic local endpoint channel %s: %s:%d",
-                        module->linux_device_name, str, inet_ntoa(sin->sin_addr),
-                        ntohs(sin->sin_port));
+    {
+        char ep_addr[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &sin->sin_addr, ep_addr, sizeof(ep_addr));
+        opal_output_verbose(15, USNIC_OUT,
+                            "btl:usnic:create_ep:%s: new usnic local endpoint channel %s: %s:%d",
+                            module->linux_device_name, str, ep_addr,
+                            ntohs(sin->sin_port));
+    }
 
     return OPAL_SUCCESS;
 }
diff --git a/opal/mca/common/ubcl/configure.m4 b/opal/mca/common/ubcl/configure.m4
index d98ebf43103..fa4af35cb7d 100644
--- a/opal/mca/common/ubcl/configure.m4
+++ b/opal/mca/common/ubcl/configure.m4
@@ -1,6 +1,6 @@
 # -*- shell-script -*-
 #
-# Copyright (c) 2024      Bull S.A.S. All rights reserved.
+# Copyright (c) 2024-2026 Bull S.A.S. All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -15,6 +15,8 @@ AC_DEFUN([MCA_opal_common_ubcl_CONFIG],[
                     [common_ubcl_happy="yes"],
                     [common_ubcl_happy="no"])
 
+    # opal/mca/common/ubcl does not handle any UBCL symbols
+    common_ubcl_LDFLAGS=""
 
     AS_IF([test "$common_ubcl_happy" = "yes"],
           [$1],
diff --git a/opal/mca/shmem/posix/shmem_posix_component.c b/opal/mca/shmem/posix/shmem_posix_component.c
index 1da5bb5ccde..3a23c6dec1c 100644
--- a/opal/mca/shmem/posix/shmem_posix_component.c
+++ b/opal/mca/shmem/posix/shmem_posix_component.c
@@ -164,6 +164,14 @@ static int posix_runtime_query(mca_base_module_t **module, int *priority, const
                          "starting run-time test...\n"));
     /* shmem_posix_shm_open successfully shm_opened - we can use posix sm! */
     if (-1 != (fd = opal_shmem_posix_shm_open(tmp_buff, OPAL_SHMEM_POSIX_FILE_LEN_MAX - 1))) {
+        /* the run-time test only needed to know that the shm_open(2)
+         * succeeded.  close the descriptor it handed back -- shm_unlink(3)
+         * below removes the name, but the descriptor would otherwise stay
+         * open for the life of the process, and this query runs on every
+         * opal_init().
+         */
+        (void) close(fd);
+
         /* free up allocated resources before we return */
         if (0 != shm_unlink(tmp_buff)) {
             int err = errno;
diff --git a/opal/runtime/opal_finalize_core.c b/opal/runtime/opal_finalize_core.c
index c7516477d44..ec914ac9115 100644
--- a/opal/runtime/opal_finalize_core.c
+++ b/opal/runtime/opal_finalize_core.c
@@ -20,6 +20,7 @@
  *                         All Rights reserved.
  * Copyright (c) 2018      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -93,6 +94,17 @@ opal_finalize_domain_t opal_init_domain = {{{0}}};
 void opal_finalize_append_cleanup(opal_cleanup_fn_t cleanup_fn, const char *fn_name,
                                   void *user_data)
 {
+    /* This may be called before opal_init_util() has established a
+     * finalize domain -- e.g., if opal_output() is used very early,
+     * before OPAL is initialized.  The first opal_output() call lazily
+     * runs opal_output_init(), which registers its finalizer here.  With
+     * no current domain, appending would dereference a NULL pointer and
+     * crash, so simply skip the registration: there is no domain to
+     * eventually run the cleanup, and OPAL is not yet up to be torn down. */
+    if (NULL == current_finalize_domain) {
+        return;
+    }
+
     opal_cleanup_fn_item_t *cleanup_item = OBJ_NEW(opal_cleanup_fn_item_t);
     assert(NULL != cleanup_item);
     cleanup_item->cleanup_fn = cleanup_fn;
diff --git a/opal/util/Makefile.am b/opal/util/Makefile.am
index afd657b5b09..3ccaa2f7685 100644
--- a/opal/util/Makefile.am
+++ b/opal/util/Makefile.am
@@ -21,6 +21,7 @@
 #                         All Rights reserved.
 # Copyright (c) 2021      Google, LLC. All rights reserved.
 # Copyright (c) 2025      Jeffrey M. Squyres.  All rights reserved.
+# Copyright (c) 2026      Stony Brook University.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -55,6 +56,7 @@ headers = \
         bit_ops.h \
         clock_gettime.h \
         cmd_line.h \
+        count_disp_array.h \
         crc.h \
 	ethtool.h \
         error.h \
diff --git a/opal/util/argv.c b/opal/util/argv.c
index cc725db824b..382af733dd7 100644
--- a/opal/util/argv.c
+++ b/opal/util/argv.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2012      Los Alamos National Security, LLC. All rights reserved.
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  *
  * $COPYRIGHT$
  *
@@ -492,8 +493,11 @@ int opal_argv_delete(int *argc, char ***argv, int start, int num_to_delete)
         *argv = tmp;
     }
 
-    /* adjust the argc */
-    (*argc) -= num_to_delete;
+    /* Adjust argc to the actual new length of the array.  "i" is the
+       index of the trailing NULL, i.e., the new element count.  Using
+       this (rather than subtracting num_to_delete) keeps argc correct
+       even when num_to_delete runs past the end of the array. */
+    *argc = i;
 
     return OPAL_SUCCESS;
 }
diff --git a/opal/util/basename.c b/opal/util/basename.c
index f5121156498..f425ea29434 100644
--- a/opal/util/basename.c
+++ b/opal/util/basename.c
@@ -13,6 +13,7 @@
  * Copyright (c) 2014-2024 Research Organization for Information Science
  *                         and Technology (RIST).  All rights reserved.
  * Copyright (c) 2014      Intel, Inc. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -103,6 +104,11 @@ char *opal_basename(const char *filename)
 
 char *opal_dirname(const char *filename)
 {
+    /* Check for the bozo case (mirrors opal_basename()) */
+    if (NULL == filename) {
+        return NULL;
+    }
+
 #if defined(HAVE_DIRNAME) || OPAL_HAVE_DIRNAME
     char *safe_tmp = strdup(filename), *result;
     if (NULL == safe_tmp) {
diff --git a/opal/util/count_disp_array.h b/opal/util/count_disp_array.h
new file mode 100644
index 00000000000..d962e69b6b2
--- /dev/null
+++ b/opal/util/count_disp_array.h
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2024   Triad National Security, LLC. All rights reserved.
+ * Copyright (c) 2025-2026 Stony Brook University.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+#ifndef OPAL_UTIL_COUNT_DISP_ARRAY_H
+#define OPAL_UTIL_COUNT_DISP_ARRAY_H
+
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include "opal_config.h"
+
+/*
+ * NOTE: This code chooses between 64-bit and 32-bit pointers by using the
+ *       least significant bit as a flag (which is possible since these
+ *       pointers will always be multiples of 4 or 8).
+ */
+typedef intptr_t opal_count_array_t;
+
+/**
+ * Sanity check to make sure the compiler respects the alignment assumptions
+ * that allow us to use the least significant bit as a flag.
+ */
+_Static_assert(_Alignof(int) >= 2, "int alignment assumption violated");
+_Static_assert(_Alignof(size_t) >= 2, "size_t alignment assumption violated");
+
+#define OPAL_COUNT_ARRAY_NULL ((opal_count_array_t)0)
+
+/**
+ * Initialize an int variant of the count array.
+ * Assumes is aligned to at least 2 bytes (i.e., least significant bit is 0).
+ */
+static inline void opal_count_array_init(opal_count_array_t *array, const int *data)
+{
+    assert(((intptr_t)data & 0x1L) == 0);
+    *array = (intptr_t)data | 0x1L;
+}
+
+/* Initialize a bigcount variant of the count array */
+static inline void opal_count_array_init_c(opal_count_array_t *array, const size_t *data)
+{
+    *array = (intptr_t)data;
+}
+
+#if OPAL_C_HAVE__GENERIC
+#define OPAL_COUNT_ARRAY_INIT(array, data) _Generic((data), \
+                                                    int *: opal_count_array_init, \
+                                                    const int *: opal_count_array_init, \
+                                                    size_t *: opal_count_array_init_c, \
+                                                    const size_t *: opal_count_array_init_c, \
+                                                    MPI_Count *: opal_count_array_init_c, \
+                                                    const MPI_Count *: opal_count_array_init_c)(array, (const void *) data)
+#else
+#define OPAL_COUNT_ARRAY_INIT(array, data) \
+    do { \
+        if (sizeof(*(data)) == sizeof(int)) { \
+            opal_count_array_init(array, (const int *) (data)); \
+        } else if (sizeof(*(data)) == sizeof(size_t)) { \
+            opal_count_array_init_c(array, (const size_t *) (data)); \
+        } \
+    } while (0)
+#endif
+
+
+static inline opal_count_array_t opal_count_array_create(const int *data)
+{
+    opal_count_array_t array;
+    opal_count_array_init(&array, data);
+    return array;
+}
+
+static inline opal_count_array_t opal_count_array_create_c(const size_t *data)
+{
+    opal_count_array_t array;
+    opal_count_array_init_c(&array, data);
+    return array;
+}
+
+static inline opal_count_array_t opal_count_array_create_with_size(const void *data, size_t size)
+{
+    if (size == sizeof(int)) {
+        return opal_count_array_create(data);
+    } else {
+        return opal_count_array_create_c(data);
+    }
+}
+
+#define OPAL_COUNT_ARRAY_CREATE(data) opal_count_array_create_with_size((data), sizeof(*(data)))
+
+
+/* Return if the internal type is 64-bit or not */
+static inline bool opal_count_array_is_64bit(opal_count_array_t array)
+{
+    return !(array & 0x1L) && sizeof(size_t) == 8;
+}
+
+static inline size_t opal_count_array_sizeof(opal_count_array_t array)
+{
+    return opal_count_array_is_64bit(array) ? sizeof(size_t) : sizeof(int);
+}
+
+static inline const void *opal_count_array_ptr(opal_count_array_t array)
+{
+    if (OPAL_LIKELY(array & 0x1L)){
+        return (const void *)(array & ~0x1L);
+    }
+    return (const void *) array;
+}
+
+/* Get a count in the array at index i */
+static inline size_t opal_count_array_get(opal_count_array_t array, size_t i)
+{
+    if (OPAL_LIKELY(array & 0x1L)){
+        const int *iptr = (const int *)(array & ~0x1L);
+        return (size_t)iptr[i];
+    }
+    return ((const size_t *)array)[i];
+}
+
+/* Set a count in the array at index i */
+static inline void opal_count_array_set(opal_count_array_t array, size_t i, size_t val)
+{
+    if (OPAL_LIKELY(array & 0x1L)){
+        int *iptr = (int *)(array & ~0x1L);
+        iptr[i] = (int)val;
+    } else {
+        size_t *sptr = (size_t *)array;
+        sptr[i] = val;
+    }
+}
+
+typedef intptr_t opal_disp_array_t;
+
+#define OPAL_DISP_ARRAY_NULL ((opal_disp_array_t)0)
+
+/* Initialize an int variant of the disp array */
+static inline void opal_disp_array_init(opal_disp_array_t *array, const int *data)
+{
+    *array = (intptr_t)data | 0x1L;
+}
+
+/* Initialize a bigcount variant of the disp array */
+static inline void opal_disp_array_init_c(opal_disp_array_t *array, const ptrdiff_t *data)
+{
+    *array = (intptr_t)data;
+}
+
+#if OPAL_C_HAVE__GENERIC
+#define OPAL_DISP_ARRAY_INIT(array, data) _Generic((data), \
+                                                   int *: opal_disp_array_init, \
+                                                   const int *: opal_disp_array_init, \
+                                                   ptrdiff_t *: opal_disp_array_init_c, \
+                                                   const ptrdiff_t *: opal_disp_array_init_c)(array, data)
+#else
+#define OPAL_DISP_ARRAY_INIT(array, data) \
+    do { \
+        if (sizeof(*(data)) == sizeof(int)) { \
+            opal_disp_array_init(array, (const int *) (data)); \
+        } else if (sizeof(*(data)) == sizeof(ptrdiff_t)) { \
+            opal_disp_array_init_c(array, (const ptrdiff_t *) (data)); \
+        } \
+    } while(0)
+#endif
+
+
+
+static inline opal_disp_array_t opal_disp_array_create(const int *data)
+{
+    opal_disp_array_t array;
+    opal_disp_array_init(&array, data);
+    return array;
+}
+
+static inline opal_disp_array_t opal_disp_array_create_c(const ptrdiff_t *data)
+{
+    opal_disp_array_t array;
+    opal_disp_array_init_c(&array, data);
+    return array;
+}
+
+static inline opal_disp_array_t opal_disp_array_create_with_size(const void *data, size_t size)
+{
+    if (size == sizeof(int)) {
+        return opal_disp_array_create(data);
+    } else {
+        return opal_disp_array_create_c(data);
+    }
+}
+
+#define OPAL_DISP_ARRAY_CREATE(data) opal_disp_array_create_with_size(data, sizeof(*(data)))
+
+
+/* Return if the internal type is 64-bit or not */
+static inline bool opal_disp_array_is_64bit(opal_disp_array_t array)
+{
+    return !(array & 0x1L) && sizeof(ptrdiff_t) == 8;
+}
+
+static inline size_t opal_disp_array_sizeof(opal_disp_array_t array)
+{
+    return opal_disp_array_is_64bit(array) ? sizeof(ptrdiff_t) : sizeof(int);
+}
+
+/* Get a displacement in the array at index i */
+static inline ptrdiff_t opal_disp_array_get(opal_disp_array_t array, size_t i)
+{
+    if (OPAL_LIKELY(array & 0x1L)){
+        const int *iptr = (const int *)(array & ~0x1L);
+        return iptr[i];
+    }
+    return ((const ptrdiff_t *)array)[i];
+}
+
+/* Set a displacement in the array at index i */
+static inline void opal_disp_array_set(opal_disp_array_t array, size_t i, ptrdiff_t val)
+{
+    if (OPAL_LIKELY(array & 0x1L)){
+        int *iptr = (int *)(array & ~0x1L);
+        iptr[i] = (int)val;
+    } else {
+        ptrdiff_t *pptr = (ptrdiff_t *)array;
+        pptr[i] = val;
+    }
+}
+
+
+/* Get a direct pointer to the data */
+static inline const void *opal_disp_array_ptr(opal_disp_array_t array)
+{
+    if (OPAL_LIKELY(array & 0x1L)){
+        return (const void *)(array & ~0x1L);
+    }
+    return (const void *)array;
+}
+
+#endif
diff --git a/opal/util/error.c b/opal/util/error.c
index 7f8be1e5817..ea3ba8c4851 100644
--- a/opal/util/error.c
+++ b/opal/util/error.c
@@ -17,6 +17,7 @@
  * Copyright (c) 2017      FUJITSU LIMITED.  All rights reserved.
  * Copyright (c) 2017      IBM Corporation. All rights reserved.
  * Copyright (c) 2018      Amazon.com, Inc. or its affiliates.  All Rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -57,7 +58,14 @@ static converter_info_t converters[MAX_CONVERTERS] = {{0}};
 
 static int opal_strerror_int(int errnum, const char **str)
 {
-    int i, ret = OPAL_SUCCESS;
+    /* Default to a non-success value so that an errnum matched by no
+       registered converter is reported as unknown by the callers
+       (opal_strerror/opal_strerror_r/opal_perror), which then format an
+       "Unknown error" string.  Previously this defaulted to OPAL_SUCCESS,
+       leaving *str == NULL for unmatched codes and causing opal_strerror()
+       to return NULL -- violating its documented contract that an unknown
+       errnum yields a (non-NULL) overwritable buffer. */
+    int i, ret = OPAL_ERROR;
     *str = NULL;
 
     for (i = 0; i < MAX_CONVERTERS; ++i) {
diff --git a/opal/util/event.c b/opal/util/event.c
index 263adecd97d..77d2cbc6121 100644
--- a/opal/util/event.c
+++ b/opal/util/event.c
@@ -152,6 +152,16 @@ int opal_event_init(void)
 
 int opal_event_finalize(void)
 {
+    if (NULL != opal_sync_event_base) {
+        opal_event_base_free(opal_sync_event_base);
+        opal_sync_event_base = NULL;
+    }
+
+    if (NULL != opal_event_config) {
+        event_config_free(opal_event_config);
+        opal_event_config = NULL;
+    }
+
     return OPAL_SUCCESS;
 }
 
diff --git a/opal/util/info_subscriber.c b/opal/util/info_subscriber.c
index 3382612ac17..cb499b53e0f 100644
--- a/opal/util/info_subscriber.c
+++ b/opal/util/info_subscriber.c
@@ -18,6 +18,7 @@
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2016-2018 IBM Corporation. All rights reserved.
  * Copyright (c) 2017-2018 Intel, Inc. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -76,6 +77,14 @@ static void infosubscriber_construct(opal_infosubscriber_t *obj)
 {
     OBJ_CONSTRUCT(&obj->s_subscriber_table, opal_hash_table_t);
     opal_hash_table_init(&obj->s_subscriber_table, 10);
+
+    /* s_info is created lazily (see opal_infosubscribe_subscribe) and is
+     * released in the destructor only when non-NULL, so it must start out
+     * NULL.  Subclasses (communicator, win, file) run after this base
+     * constructor; a standalone OBJ_NEW(opal_infosubscriber_t) has no
+     * subclass constructor, so without this it would be left uninitialized
+     * and dereferenced as a garbage pointer. */
+    obj->s_info = NULL;
 }
 
 static void infosubscriber_destruct(opal_infosubscriber_t *obj)
diff --git a/opal/util/net.c b/opal/util/net.c
index ec0c372dd99..e74e778d0f1 100644
--- a/opal/util/net.c
+++ b/opal/util/net.c
@@ -20,6 +20,7 @@
  *                         reserved.
  * Copyright (c) 2018      Triad National Security, LLC. All rights
  *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -211,8 +212,11 @@ bool opal_net_islocalhost(const struct sockaddr *addr)
     case AF_INET: {
         const struct sockaddr_in *inaddr = (struct sockaddr_in *) addr;
         /* if it's in the 127. domain, it shouldn't be routed
-           (0x7f == 127) */
-        if (0x7F000000 == (0x7F000000 & ntohl(inaddr->sin_addr.s_addr))) {
+           (0x7f == 127).  Mask the full top byte (0xFF000000), not just
+           its low 7 bits (0x7F000000): the latter also matches 255.x.x.x
+           because 0xFF & 0x7F == 0x7F, incorrectly reporting 255.0.0.0 as
+           localhost. */
+        if (0x7F000000 == (0xFF000000 & ntohl(inaddr->sin_addr.s_addr))) {
             return true;
         }
         return false;
@@ -406,7 +410,11 @@ char *opal_net_get_hostname(const struct sockaddr *addr)
     }
     return name;
 #    else
-    return inet_ntoa(((struct sockaddr_in *) addr)->sin_addr);
+    {
+        static char ntop_buf[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &((struct sockaddr_in *) addr)->sin_addr, ntop_buf, sizeof(ntop_buf));
+        return ntop_buf;
+    }
 #    endif
 }
 
diff --git a/opal/util/opal_getcwd.c b/opal/util/opal_getcwd.c
index da484e3eec0..6931fa13f4d 100644
--- a/opal/util/opal_getcwd.c
+++ b/opal/util/opal_getcwd.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2007      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -83,9 +84,10 @@ int opal_getcwd(char *buf, size_t size)
 #endif
 
     /* If we got here, pwd is pointing to the result that we want to
-       give.  Ensure the user's buffer is long enough.  If it is, copy
-       in the value and be done. */
-    if (strlen(pwd) > size) {
+       give.  Ensure the user's buffer is long enough (it must hold the
+       string *and* a NUL terminator, so it needs strlen(pwd)+1 bytes).
+       If it is long enough, copy in the value and be done. */
+    if (strlen(pwd) >= size) {
         /* if it isn't big enough, give them as much
          * of the basename as possible
          */
diff --git a/opal/util/string_copy.c b/opal/util/string_copy.c
index 531abb1f098..f4647a6a602 100644
--- a/opal/util/string_copy.c
+++ b/opal/util/string_copy.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026 Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -28,6 +29,12 @@ void opal_string_copy(char *dest, const char *src, size_t dest_len)
     // obvious.
     assert(dest_len <= OPAL_MAX_SIZE_ALLOWED_BY_OPAL_STRING_COPY);
 
+    /* A zero-length destination buffer cannot hold even a NUL
+       terminator; there is nothing safe to write. */
+    if (0 == dest_len) {
+        return;
+    }
+
     for (i = 0; i < dest_len; ++i, ++src, ++new_dest) {
         *new_dest = *src;
         if ('\0' == *src) {
diff --git a/opal/util/uri.c b/opal/util/uri.c
index 233037ee246..3343076ead4 100644
--- a/opal/util/uri.c
+++ b/opal/util/uri.c
@@ -4,6 +4,7 @@
  * Copyright (c) 2015      Research Organization for Information Science
  *                         and Technology (RIST). All rights reserved.
  * Copyright (c) 2018      Amazon.com, Inc. or its affiliates.  All Rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -73,9 +74,16 @@ char *opal_filename_to_uri(const char *filename, const char *hostname)
     }
     /* escape them if necessary */
     if (0 < n) {
-        fn = (char *) malloc(strlen(filename) + n + 1);
+        /* Worst case: every character is escaped (backslash + character),
+           so allocate 2 bytes per character plus the NUL terminator.  n
+           only records whether any reserved character is present -- it
+           counts reserved types, not occurrences, so it cannot size this
+           buffer safely when a reserved character repeats. */
+        fn = (char *) malloc(2 * strlen(filename) + 1);
         i = 0;
-        for (k = 0; k < strlen(filename) - 1; k++) {
+        /* Iterate over every character of filename; a previous "- 1" bound
+           here dropped the last character whenever escaping was needed. */
+        for (k = 0; k < strlen(filename); k++) {
             for (j = 0; j < strlen(uri_reserved_path_chars) - 1; j++) {
                 if (filename[k] == uri_reserved_path_chars[j]) {
                     fn[i] = '\\';
diff --git a/oshmem/mca/sshmem/base/sshmem_base_open.c b/oshmem/mca/sshmem/base/sshmem_base_open.c
index 2694120e1cf..e54299167af 100644
--- a/oshmem/mca/sshmem/base/sshmem_base_open.c
+++ b/oshmem/mca/sshmem/base/sshmem_base_open.c
@@ -31,7 +31,7 @@
  * globals
  */
 
-void *mca_sshmem_base_start_address = (void *)UINTPTR_MAX;
+void *mca_sshmem_base_start_address = NULL;
 
 char * mca_sshmem_base_backing_file_dir = NULL;
 
diff --git a/oshmem/tools/oshmem_info/param.c b/oshmem/tools/oshmem_info/param.c
index 601ceb167f7..29920c99d4c 100644
--- a/oshmem/tools/oshmem_info/param.c
+++ b/oshmem/tools/oshmem_info/param.c
@@ -116,7 +116,7 @@ void oshmem_info_do_config(bool want_all)
     /* setup strings that require allocation */
     if (OMPI_BUILD_FORTRAN_BINDINGS >= OMPI_FORTRAN_MPIFH_BINDINGS) {
         (void)opal_asprintf(&fortran_binding, "yes (%s)",
-                       (OPAL_HAVE_WEAK_SYMBOLS ? "all" :
+                       (OPAL_HAVE_WEAK_ALIASES ? "all" :
                         (OMPI_FORTRAN_CAPS ? "caps" :
                          (OMPI_FORTRAN_PLAIN ? "lower case" :
                           (OMPI_FORTRAN_SINGLE_UNDERSCORE ? "single underscore" : "double underscore")))));
diff --git a/specs/llms-friendly-docs/sample-records.jsonl b/specs/llms-friendly-docs/sample-records.jsonl
new file mode 100644
index 00000000000..8bf5b68ad38
--- /dev/null
+++ b/specs/llms-friendly-docs/sample-records.jsonl
@@ -0,0 +1,5 @@
+{"bindings": [{"language": "c", "large_count": false, "parameters": [{"description": "C only: Pointer to the number of arguments.", "direction": "inout", "intent": null, "name": "argc", "optional": false, "type": "ARGUMENT_COUNT"}, {"description": "C only: Argument vector.", "direction": "inout", "intent": null, "name": "argv", "optional": false, "type": "ARGUMENT_LIST"}], "procedure": "MPI_Init", "return_convention": "int return code", "signature": "int MPI_Init(int* argc, char*** argv)"}, {"language": "fortran_mpifh", "large_count": false, "parameters": [{"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Init", "return_convention": "ierror argument", "signature": "MPI_INIT(IERROR)\n\tINTEGER IERROR"}, {"language": "fortran_use_mpi", "large_count": false, "parameters": [{"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Init", "return_convention": "ierror argument", "signature": "MPI_INIT(IERROR)\n\tINTEGER IERROR"}, {"language": "fortran_mpi_f08", "large_count": false, "parameters": [{"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": true, "type": "ERROR_CODE"}], "procedure": "MPI_Init", "return_convention": "ierror argument", "signature": "MPI_Init(ierror)\n\tINTEGER, OPTIONAL, INTENT(OUT) :: ierror"}], "category": "process", "docset": {"ompi_series": "v6.1.x", "ompi_version": "v6.1.0a1", "schema_version": 1}, "documented_with": [], "errors": {"convention": "C: int return code; Fortran: ierror argument.", "url": "../man-openmpi/man3/MPI_Errors.3.html"}, "kind": "standard", "languages": ["c", "fortran_mpi_f08", "fortran_mpifh", "fortran_use_mpi"], "name": "MPI_Init", "parameters": [{"description": "C only: Pointer to the number of arguments.", "direction": "inout", "intent": null, "name": "argc", "optional": "unknown", "type": "ARGUMENT_COUNT"}, {"description": "C only: Argument vector.", "direction": "inout", "intent": null, "name": "argv", "optional": "unknown", "type": "ARGUMENT_LIST"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": null, "name": "ierror", "optional": "unknown", "type": "ERROR_CODE"}], "project": "open-mpi", "schema_version": 1, "seealso": ["MPI_Init_thread", "MPI_Initialized", "MPI_Finalize", "MPI_Finalized", "MPI_Session_finalize", "MPI_Session_init"], "semantics": {"blocking": null, "collective": false, "initialization_required": null, "local": null, "threading_notes": null}, "sources": {"binding_metadata": "pympistandard", "rst": "man-openmpi/man3/MPI_Init.3.rst"}, "standard": {"version": null}, "urls": {"html": "../man-openmpi/man3/MPI_Init.3.html", "markdown": "man-openmpi/man3/MPI_Init.3.md"}}
+{"bindings": [{"language": "c", "large_count": false, "parameters": [{"description": "Initial address of send buffer (choice).", "direction": "in", "intent": "const", "name": "buf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (nonnegative integer).", "direction": "in", "intent": null, "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of each send buffer element (handle).", "direction": "in", "intent": null, "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Rank of destination (integer).", "direction": "in", "intent": null, "name": "dest", "optional": false, "type": "RANK"}, {"description": "Message tag (integer).", "direction": "in", "intent": null, "name": "tag", "optional": false, "type": "TAG"}, {"description": "Communicator (handle).", "direction": "in", "intent": null, "name": "comm", "optional": false, "type": "COMMUNICATOR"}], "procedure": "MPI_Send", "return_convention": "int return code", "signature": "int MPI_Send(const void* buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)"}, {"language": "c", "large_count": true, "parameters": [{"description": "Initial address of send buffer (choice).", "direction": "in", "intent": "const", "name": "buf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (nonnegative integer).", "direction": "in", "intent": null, "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of each send buffer element (handle).", "direction": "in", "intent": null, "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Rank of destination (integer).", "direction": "in", "intent": null, "name": "dest", "optional": false, "type": "RANK"}, {"description": "Message tag (integer).", "direction": "in", "intent": null, "name": "tag", "optional": false, "type": "TAG"}, {"description": "Communicator (handle).", "direction": "in", "intent": null, "name": "comm", "optional": false, "type": "COMMUNICATOR"}], "procedure": "MPI_Send_c", "return_convention": "int return code", "signature": "int MPI_Send_c(const void* buf, MPI_Count count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)"}, {"language": "fortran_mpifh", "large_count": false, "parameters": [{"description": "Initial address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "buf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (nonnegative integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of each send buffer element (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Rank of destination (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "dest", "optional": false, "type": "RANK"}, {"description": "Message tag (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "tag", "optional": false, "type": "TAG"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Send", "return_convention": "ierror argument", "signature": "MPI_SEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, IERROR)\n\t<type> BUF(*)\n\tINTEGER COUNT, DATATYPE, DEST, TAG, COMM, IERROR"}, {"language": "fortran_use_mpi", "large_count": false, "parameters": [{"description": "Initial address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "buf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (nonnegative integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of each send buffer element (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Rank of destination (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "dest", "optional": false, "type": "RANK"}, {"description": "Message tag (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "tag", "optional": false, "type": "TAG"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Send", "return_convention": "ierror argument", "signature": "MPI_SEND(BUF, COUNT, DATATYPE, DEST, TAG, COMM, IERROR)\n\t<type> BUF(*)\n\tINTEGER COUNT, DATATYPE, DEST, TAG, COMM, IERROR"}, {"language": "fortran_mpi_f08", "large_count": false, "parameters": [{"description": "Initial address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "buf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (nonnegative integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of each send buffer element (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Rank of destination (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "dest", "optional": false, "type": "RANK"}, {"description": "Message tag (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "tag", "optional": false, "type": "TAG"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": true, "type": "ERROR_CODE"}], "procedure": "MPI_Send", "return_convention": "ierror argument", "signature": "MPI_Send(buf, count, datatype, dest, tag, comm, ierror)\n\tTYPE(*), DIMENSION(..), INTENT(IN) :: buf\n\tINTEGER, INTENT(IN) :: count, dest, tag\n\tTYPE(MPI_Datatype), INTENT(IN) :: datatype\n\tTYPE(MPI_Comm), INTENT(IN) :: comm\n\tINTEGER, OPTIONAL, INTENT(OUT) :: ierror"}, {"language": "fortran_mpi_f08", "large_count": true, "parameters": [{"description": "Initial address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "buf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (nonnegative integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of each send buffer element (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Rank of destination (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "dest", "optional": false, "type": "RANK"}, {"description": "Message tag (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "tag", "optional": false, "type": "TAG"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": true, "type": "ERROR_CODE"}], "procedure": "MPI_Send", "return_convention": "ierror argument", "signature": "MPI_Send(buf, count, datatype, dest, tag, comm, ierror)\n\tTYPE(*), DIMENSION(..), INTENT(IN) :: buf\n\tINTEGER(KIND=MPI_COUNT_KIND), INTENT(IN) :: count\n\tTYPE(MPI_Datatype), INTENT(IN) :: datatype\n\tINTEGER, INTENT(IN) :: dest, tag\n\tTYPE(MPI_Comm), INTENT(IN) :: comm\n\tINTEGER, OPTIONAL, INTENT(OUT) :: ierror"}], "category": "point-to-point", "docset": {"ompi_series": "v6.1.x", "ompi_version": "v6.1.0a1", "schema_version": 1}, "documented_with": [], "errors": {"convention": "C: int return code; Fortran: ierror argument.", "url": "../man-openmpi/man3/MPI_Errors.3.html"}, "kind": "standard", "languages": ["c", "fortran_mpi_f08", "fortran_mpifh", "fortran_use_mpi"], "name": "MPI_Send", "parameters": [{"description": "Initial address of send buffer (choice).", "direction": "in", "intent": null, "name": "buf", "optional": "unknown", "type": "BUFFER"}, {"description": "Number of elements in send buffer (nonnegative integer).", "direction": "in", "intent": null, "name": "count", "optional": "unknown", "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of each send buffer element (handle).", "direction": "in", "intent": null, "name": "datatype", "optional": "unknown", "type": "DATATYPE"}, {"description": "Rank of destination (integer).", "direction": "in", "intent": null, "name": "dest", "optional": "unknown", "type": "RANK"}, {"description": "Message tag (integer).", "direction": "in", "intent": null, "name": "tag", "optional": "unknown", "type": "TAG"}, {"description": "Communicator (handle).", "direction": "in", "intent": null, "name": "comm", "optional": "unknown", "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": null, "name": "ierror", "optional": "unknown", "type": "ERROR_CODE"}], "project": "open-mpi", "schema_version": 1, "seealso": ["MPI_Isend", "MPI_Bsend", "MPI_Recv"], "semantics": {"blocking": null, "collective": false, "initialization_required": null, "local": null, "threading_notes": null}, "sources": {"binding_metadata": "pympistandard", "rst": "man-openmpi/man3/MPI_Send.3.rst"}, "standard": {"version": null}, "urls": {"html": "../man-openmpi/man3/MPI_Send.3.html", "markdown": "man-openmpi/man3/MPI_Send.3.md"}}
+{"bindings": [{"language": "c", "large_count": false, "parameters": [{"description": "Starting address of send buffer (choice).", "direction": "in", "intent": "const", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Starting address of receive buffer (choice).", "direction": "out", "intent": null, "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (integer).", "direction": "in", "intent": null, "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of elements of send buffer (handle).", "direction": "in", "intent": null, "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Operation (handle).", "direction": "in", "intent": null, "name": "op", "optional": false, "type": "OPERATION"}, {"description": "Communicator (handle).", "direction": "in", "intent": null, "name": "comm", "optional": false, "type": "COMMUNICATOR"}], "procedure": "MPI_Allreduce", "return_convention": "int return code", "signature": "int MPI_Allreduce(const void* sendbuf, void* recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)"}, {"language": "c", "large_count": true, "parameters": [{"description": "Starting address of send buffer (choice).", "direction": "in", "intent": "const", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Starting address of receive buffer (choice).", "direction": "out", "intent": null, "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (integer).", "direction": "in", "intent": null, "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of elements of send buffer (handle).", "direction": "in", "intent": null, "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Operation (handle).", "direction": "in", "intent": null, "name": "op", "optional": false, "type": "OPERATION"}, {"description": "Communicator (handle).", "direction": "in", "intent": null, "name": "comm", "optional": false, "type": "COMMUNICATOR"}], "procedure": "MPI_Allreduce_c", "return_convention": "int return code", "signature": "int MPI_Allreduce_c(const void* sendbuf, void* recvbuf, MPI_Count count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)"}, {"language": "fortran_mpifh", "large_count": false, "parameters": [{"description": "Starting address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Starting address of receive buffer (choice).", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of elements of send buffer (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Operation (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "op", "optional": false, "type": "OPERATION"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Allreduce", "return_convention": "ierror argument", "signature": "MPI_ALLREDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, IERROR)\n\t<type> SENDBUF(*), RECVBUF(*)\n\tINTEGER COUNT, DATATYPE, OP, COMM, IERROR"}, {"language": "fortran_use_mpi", "large_count": false, "parameters": [{"description": "Starting address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Starting address of receive buffer (choice).", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of elements of send buffer (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Operation (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "op", "optional": false, "type": "OPERATION"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Allreduce", "return_convention": "ierror argument", "signature": "MPI_ALLREDUCE(SENDBUF, RECVBUF, COUNT, DATATYPE, OP, COMM, IERROR)\n\t<type> SENDBUF(*), RECVBUF(*)\n\tINTEGER COUNT, DATATYPE, OP, COMM, IERROR"}, {"language": "fortran_mpi_f08", "large_count": false, "parameters": [{"description": "Starting address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Starting address of receive buffer (choice).", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of elements of send buffer (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Operation (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "op", "optional": false, "type": "OPERATION"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": true, "type": "ERROR_CODE"}], "procedure": "MPI_Allreduce", "return_convention": "ierror argument", "signature": "MPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm, ierror)\n\tTYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf\n\tTYPE(*), DIMENSION(..) :: recvbuf\n\tINTEGER, INTENT(IN) :: count\n\tTYPE(MPI_Datatype), INTENT(IN) :: datatype\n\tTYPE(MPI_Op), INTENT(IN) :: op\n\tTYPE(MPI_Comm), INTENT(IN) :: comm\n\tINTEGER, OPTIONAL, INTENT(OUT) :: ierror"}, {"language": "fortran_mpi_f08", "large_count": true, "parameters": [{"description": "Starting address of send buffer (choice).", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Starting address of receive buffer (choice).", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Number of elements in send buffer (integer).", "direction": "in", "intent": "INTENT(IN)", "name": "count", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of elements of send buffer (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "datatype", "optional": false, "type": "DATATYPE"}, {"description": "Operation (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "op", "optional": false, "type": "OPERATION"}, {"description": "Communicator (handle).", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": true, "type": "ERROR_CODE"}], "procedure": "MPI_Allreduce", "return_convention": "ierror argument", "signature": "MPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm, ierror)\n\tTYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf\n\tTYPE(*), DIMENSION(..) :: recvbuf\n\tINTEGER(KIND=MPI_COUNT_KIND), INTENT(IN) :: count\n\tTYPE(MPI_Datatype), INTENT(IN) :: datatype\n\tTYPE(MPI_Op), INTENT(IN) :: op\n\tTYPE(MPI_Comm), INTENT(IN) :: comm\n\tINTEGER, OPTIONAL, INTENT(OUT) :: ierror"}], "category": "collective", "docset": {"ompi_series": "v6.1.x", "ompi_version": "v6.1.0a1", "schema_version": 1}, "documented_with": ["MPI_Iallreduce", "MPI_Allreduce_init"], "errors": {"convention": "C: int return code; Fortran: ierror argument.", "url": "../man-openmpi/man3/MPI_Errors.3.html"}, "kind": "standard", "languages": ["c", "fortran_mpi_f08", "fortran_mpifh", "fortran_use_mpi"], "name": "MPI_Allreduce", "parameters": [{"description": "Starting address of send buffer (choice).", "direction": "in", "intent": null, "name": "sendbuf", "optional": "unknown", "type": "BUFFER"}, {"description": "Starting address of receive buffer (choice).", "direction": "out", "intent": null, "name": "recvbuf", "optional": "unknown", "type": "BUFFER"}, {"description": "Number of elements in send buffer (integer).", "direction": "in", "intent": null, "name": "count", "optional": "unknown", "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Datatype of elements of send buffer (handle).", "direction": "in", "intent": null, "name": "datatype", "optional": "unknown", "type": "DATATYPE"}, {"description": "Operation (handle).", "direction": "in", "intent": null, "name": "op", "optional": "unknown", "type": "OPERATION"}, {"description": "Communicator (handle).", "direction": "in", "intent": null, "name": "comm", "optional": "unknown", "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status (integer).", "direction": "out", "intent": null, "name": "ierror", "optional": "unknown", "type": "ERROR_CODE"}], "project": "open-mpi", "schema_version": 1, "seealso": [], "semantics": {"blocking": null, "collective": true, "initialization_required": null, "local": null, "threading_notes": null}, "sources": {"binding_metadata": "pympistandard", "rst": "man-openmpi/man3/MPI_Allreduce.3.rst"}, "standard": {"version": null}, "urls": {"html": "../man-openmpi/man3/MPI_Allreduce.3.html", "markdown": "man-openmpi/man3/MPI_Allreduce.3.md"}}
+{"bindings": [{"language": "c", "large_count": false, "parameters": [{"description": "Starting address of send buffer.", "direction": "in", "intent": "const", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry i specifies the number of elements to send to rank i.", "direction": "in", "intent": "const", "name": "sendcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry i specifies the displacement (in bytes, offset from *sendbuf) from which to send data to rank i.*", "direction": "in", "intent": "const", "name": "sdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry i specifies the datatype to use when sending data to rank i.", "direction": "in", "intent": "const", "name": "sendtypes", "optional": false, "type": "DATATYPE"}, {"description": "Address of receive buffer.", "direction": "out", "intent": null, "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry j specifies the number of elements to receive from rank j.", "direction": "in", "intent": "const", "name": "recvcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry j specifies the displacement (in bytes, offset from *recvbuf) to which data from rank j should* be written.", "direction": "in", "intent": "const", "name": "rdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry j specifies the datatype to use when receiving data from rank j.", "direction": "in", "intent": "const", "name": "recvtypes", "optional": false, "type": "DATATYPE"}, {"description": "Communicator over which data is to be exchanged.", "direction": "in", "intent": null, "name": "comm", "optional": false, "type": "COMMUNICATOR"}], "procedure": "MPI_Alltoallw", "return_convention": "int return code", "signature": "int MPI_Alltoallw(const void* sendbuf, const int sendcounts[], const int sdispls[], const MPI_Datatype sendtypes[], void* recvbuf, const int recvcounts[], const int rdispls[], const MPI_Datatype recvtypes[], MPI_Comm comm)"}, {"language": "c", "large_count": true, "parameters": [{"description": "Starting address of send buffer.", "direction": "in", "intent": "const", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry i specifies the number of elements to send to rank i.", "direction": "in", "intent": "const", "name": "sendcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry i specifies the displacement (in bytes, offset from *sendbuf) from which to send data to rank i.*", "direction": "in", "intent": "const", "name": "sdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry i specifies the datatype to use when sending data to rank i.", "direction": "in", "intent": "const", "name": "sendtypes", "optional": false, "type": "DATATYPE"}, {"description": "Address of receive buffer.", "direction": "out", "intent": null, "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry j specifies the number of elements to receive from rank j.", "direction": "in", "intent": "const", "name": "recvcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry j specifies the displacement (in bytes, offset from *recvbuf) to which data from rank j should* be written.", "direction": "in", "intent": "const", "name": "rdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry j specifies the datatype to use when receiving data from rank j.", "direction": "in", "intent": "const", "name": "recvtypes", "optional": false, "type": "DATATYPE"}, {"description": "Communicator over which data is to be exchanged.", "direction": "in", "intent": null, "name": "comm", "optional": false, "type": "COMMUNICATOR"}], "procedure": "MPI_Alltoallw_c", "return_convention": "int return code", "signature": "int MPI_Alltoallw_c(const void* sendbuf, const MPI_Count sendcounts[], const MPI_Aint sdispls[], const MPI_Datatype sendtypes[], void* recvbuf, const MPI_Count recvcounts[], const MPI_Aint rdispls[], const MPI_Datatype recvtypes[], MPI_Comm comm)"}, {"language": "fortran_mpifh", "large_count": false, "parameters": [{"description": "Starting address of send buffer.", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry i specifies the number of elements to send to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry i specifies the displacement (in bytes, offset from *sendbuf) from which to send data to rank i.*", "direction": "in", "intent": "INTENT(IN)", "name": "sdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry i specifies the datatype to use when sending data to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendtypes", "optional": false, "type": "DATATYPE"}, {"description": "Address of receive buffer.", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry j specifies the number of elements to receive from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry j specifies the displacement (in bytes, offset from *recvbuf) to which data from rank j should* be written.", "direction": "in", "intent": "INTENT(IN)", "name": "rdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry j specifies the datatype to use when receiving data from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvtypes", "optional": false, "type": "DATATYPE"}, {"description": "Communicator over which data is to be exchanged.", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status.", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Alltoallw", "return_convention": "ierror argument", "signature": "MPI_ALLTOALLW(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPES, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPES, COMM, IERROR)\n\t<type> SENDBUF(*), RECVBUF(*)\n\tINTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPES(*), RECVCOUNTS(*), RDISPLS(*), RECVTYPES(*), COMM, IERROR"}, {"language": "fortran_use_mpi", "large_count": false, "parameters": [{"description": "Starting address of send buffer.", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry i specifies the number of elements to send to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry i specifies the displacement (in bytes, offset from *sendbuf) from which to send data to rank i.*", "direction": "in", "intent": "INTENT(IN)", "name": "sdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry i specifies the datatype to use when sending data to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendtypes", "optional": false, "type": "DATATYPE"}, {"description": "Address of receive buffer.", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry j specifies the number of elements to receive from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry j specifies the displacement (in bytes, offset from *recvbuf) to which data from rank j should* be written.", "direction": "in", "intent": "INTENT(IN)", "name": "rdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry j specifies the datatype to use when receiving data from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvtypes", "optional": false, "type": "DATATYPE"}, {"description": "Communicator over which data is to be exchanged.", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status.", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": false, "type": "ERROR_CODE"}], "procedure": "MPI_Alltoallw", "return_convention": "ierror argument", "signature": "MPI_ALLTOALLW(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPES, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPES, COMM, IERROR)\n\t<type> SENDBUF(*), RECVBUF(*)\n\tINTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPES(*), RECVCOUNTS(*), RDISPLS(*), RECVTYPES(*), COMM, IERROR"}, {"language": "fortran_mpi_f08", "large_count": false, "parameters": [{"description": "Starting address of send buffer.", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry i specifies the number of elements to send to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry i specifies the displacement (in bytes, offset from *sendbuf) from which to send data to rank i.*", "direction": "in", "intent": "INTENT(IN)", "name": "sdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry i specifies the datatype to use when sending data to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendtypes", "optional": false, "type": "DATATYPE"}, {"description": "Address of receive buffer.", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry j specifies the number of elements to receive from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry j specifies the displacement (in bytes, offset from *recvbuf) to which data from rank j should* be written.", "direction": "in", "intent": "INTENT(IN)", "name": "rdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry j specifies the datatype to use when receiving data from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvtypes", "optional": false, "type": "DATATYPE"}, {"description": "Communicator over which data is to be exchanged.", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status.", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": true, "type": "ERROR_CODE"}], "procedure": "MPI_Alltoallw", "return_convention": "ierror argument", "signature": "MPI_Alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, ierror)\n\tTYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf\n\tINTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*)\n\tTYPE(MPI_Datatype), INTENT(IN) :: sendtypes(*), recvtypes(*)\n\tTYPE(*), DIMENSION(..) :: recvbuf\n\tTYPE(MPI_Comm), INTENT(IN) :: comm\n\tINTEGER, OPTIONAL, INTENT(OUT) :: ierror"}, {"language": "fortran_mpi_f08", "large_count": true, "parameters": [{"description": "Starting address of send buffer.", "direction": "in", "intent": "INTENT(IN)", "name": "sendbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry i specifies the number of elements to send to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry i specifies the displacement (in bytes, offset from *sendbuf) from which to send data to rank i.*", "direction": "in", "intent": "INTENT(IN)", "name": "sdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry i specifies the datatype to use when sending data to rank i.", "direction": "in", "intent": "INTENT(IN)", "name": "sendtypes", "optional": false, "type": "DATATYPE"}, {"description": "Address of receive buffer.", "direction": "out", "intent": "INTENT(OUT)", "name": "recvbuf", "optional": false, "type": "BUFFER"}, {"description": "Integer array, where entry j specifies the number of elements to receive from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvcounts", "optional": false, "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry j specifies the displacement (in bytes, offset from *recvbuf) to which data from rank j should* be written.", "direction": "in", "intent": "INTENT(IN)", "name": "rdispls", "optional": false, "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry j specifies the datatype to use when receiving data from rank j.", "direction": "in", "intent": "INTENT(IN)", "name": "recvtypes", "optional": false, "type": "DATATYPE"}, {"description": "Communicator over which data is to be exchanged.", "direction": "in", "intent": "INTENT(IN)", "name": "comm", "optional": false, "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status.", "direction": "out", "intent": "INTENT(OUT)", "name": "ierror", "optional": true, "type": "ERROR_CODE"}], "procedure": "MPI_Alltoallw", "return_convention": "ierror argument", "signature": "MPI_Alltoallw(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, recvcounts, rdispls, recvtypes, comm, ierror)\n\tTYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf\n\tINTEGER(KIND=MPI_COUNT_KIND), INTENT(IN) :: sendcounts(*), recvcounts(*)\n\tINTEGER(KIND=MPI_ADDRESS_KIND), INTENT(IN) :: sdispls(*), rdispls(*)\n\tTYPE(MPI_Datatype), INTENT(IN) :: sendtypes(*), recvtypes(*)\n\tTYPE(*), DIMENSION(..) :: recvbuf\n\tTYPE(MPI_Comm), INTENT(IN) :: comm\n\tINTEGER, OPTIONAL, INTENT(OUT) :: ierror"}], "category": "collective", "docset": {"ompi_series": "v6.1.x", "ompi_version": "v6.1.0a1", "schema_version": 1}, "documented_with": ["MPI_Ialltoallw", "MPI_Alltoallw_init"], "errors": {"convention": "C: int return code; Fortran: ierror argument.", "url": "../man-openmpi/man3/MPI_Errors.3.html"}, "kind": "standard", "languages": ["c", "fortran_mpi_f08", "fortran_mpifh", "fortran_use_mpi"], "name": "MPI_Alltoallw", "parameters": [{"description": "Starting address of send buffer.", "direction": "in", "intent": null, "name": "sendbuf", "optional": "unknown", "type": "BUFFER"}, {"description": "Integer array, where entry i specifies the number of elements to send to rank i.", "direction": "in", "intent": null, "name": "sendcounts", "optional": "unknown", "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry i specifies the displacement (in bytes, offset from *sendbuf) from which to send data to rank i.*", "direction": "in", "intent": null, "name": "sdispls", "optional": "unknown", "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry i specifies the datatype to use when sending data to rank i.", "direction": "in", "intent": null, "name": "sendtypes", "optional": "unknown", "type": "DATATYPE"}, {"description": "Address of receive buffer.", "direction": "out", "intent": null, "name": "recvbuf", "optional": "unknown", "type": "BUFFER"}, {"description": "Integer array, where entry j specifies the number of elements to receive from rank j.", "direction": "in", "intent": null, "name": "recvcounts", "optional": "unknown", "type": "POLYXFER_NUM_ELEM_NNI"}, {"description": "Integer array, where entry j specifies the displacement (in bytes, offset from *recvbuf) to which data from rank j should* be written.", "direction": "in", "intent": null, "name": "rdispls", "optional": "unknown", "type": "POLYDISPLACEMENT"}, {"description": "Datatype array, where entry j specifies the datatype to use when receiving data from rank j.", "direction": "in", "intent": null, "name": "recvtypes", "optional": "unknown", "type": "DATATYPE"}, {"description": "Communicator over which data is to be exchanged.", "direction": "in", "intent": null, "name": "comm", "optional": "unknown", "type": "COMMUNICATOR"}, {"description": "Fortran only: Error status.", "direction": "out", "intent": null, "name": "ierror", "optional": "unknown", "type": "ERROR_CODE"}], "project": "open-mpi", "schema_version": 1, "seealso": ["MPI_Alltoall", "MPI_Alltoallv"], "semantics": {"blocking": null, "collective": true, "initialization_required": null, "local": null, "threading_notes": null}, "sources": {"binding_metadata": "pympistandard", "rst": "man-openmpi/man3/MPI_Alltoallw.3.rst"}, "standard": {"version": null}, "urls": {"html": "../man-openmpi/man3/MPI_Alltoallw.3.html", "markdown": "man-openmpi/man3/MPI_Alltoallw.3.md"}}
+{"bindings": [{"language": "c", "large_count": false, "parameters": [], "procedure": "MPIX_Query_cuda_support", "return_convention": "int return code", "signature": "int MPIX_Query_cuda_support(void)"}], "category": "extension", "docset": {"ompi_series": "v6.1.x", "ompi_version": "v6.1.0a1", "schema_version": 1}, "documented_with": [], "errors": {"convention": null, "url": "../man-openmpi/man3/MPI_Errors.3.html"}, "kind": "extension", "languages": ["c"], "name": "MPIX_Query_cuda_support", "parameters": [], "project": "open-mpi", "schema_version": 1, "seealso": ["MPIX_Query_rocm_support"], "semantics": null, "sources": {"binding_metadata": "rst", "rst": "man-openmpi/man3/MPIX_Query_cuda_support.3.rst"}, "standard": null, "urls": {"html": "../man-openmpi/man3/MPIX_Query_cuda_support.3.html", "markdown": "man-openmpi/man3/MPIX_Query_cuda_support.3.md"}}
diff --git a/specs/llms-friendly-docs/spec.md b/specs/llms-friendly-docs/spec.md
new file mode 100644
index 00000000000..a28caf8af37
--- /dev/null
+++ b/specs/llms-friendly-docs/spec.md
@@ -0,0 +1,350 @@
+# LLM-friendly documentation artifacts
+
+Open MPI publishes human-oriented documentation as Sphinx-rendered HTML and Unix manual pages. This page specifies additional generated artifacts intended for consumption by Large Language Models (LLMs), retrieval systems, and coding assistants.
+
+The initial scope is the public Open MPI MPI library APIs: C, `mpif.h`, `use mpi`, and `use mpi_f08`. The section-1 command man pages (`mpirun`, `ompi_info`, the wrapper compilers, ...) are also published as a Markdown corpus — these are commands rather than MPI APIs, so they get Markdown pages but no JSONL catalog records. OpenSHMEM is explicitly **deferred**: the same publication structure can later be applied to OpenSHMEM, but only once someone actually asks for it. This spec does not cover OpenSHMEM.
+
+## Goals
+
+The LLM-friendly documentation artifacts should:
+
+- use the existing RST manual pages and MPI binding metadata as the source of truth;
+- publish stable, versioned URLs on <https://docs.open-mpi.org/>;
+- provide concise Markdown for text-oriented consumers;
+- provide machine-readable API metadata for tools that generate or analyze MPI application code;
+- distinguish MPI Standard APIs from Open MPI extensions such as `MPIX_*` and `OMPI_*`;
+- be reproducible: identical sources at a given commit produce byte-identical semantic artifacts;
+- avoid creating a second hand-maintained API reference.
+
+## Non-goals
+
+These artifacts are not a replacement for the MPI Standard, the human-facing Open MPI documentation, or the installed Unix manual pages. They should not document Open MPI internal implementation interfaces as if they were public application APIs. They do not add a new build-time dependency for users building from official release tarballs.
+
+## Sources of truth and the data model
+
+There are two distinct API populations, with two different extraction paths. Implementers must keep them separate.
+
+### Standard MPI APIs (metadata-driven)
+
+Standard MPI procedures are described by structured metadata that already drives `docs/generate-mpi-man3-bindings.py`:
+
+- `3rd-party/pympistandard` (the MPI Forum Python library), loaded from the embedded source tree;
+- `docs/mpi-standard-apis.json` (the MPI Forum `apis.json`, copied into the tree).
+
+`pympistandard` exposes exactly **three** rendered binding strings per procedure: C (`iso_c`), fixed-form Fortran (`f90`), and `use mpi_f08` (`f08`). It also exposes per-parameter metadata (`name`, `param_direction`, `kind`, `optional`, `large_only`, `constant`, `desc`, …) and an "embiggened" (large-count) variant when one exists.
+
+For standard APIs:
+
+- **Structured parameter fields** (direction, kind/type, optionality, large-count) come from `mpi-standard-apis.json` / `pympistandard`. These are authoritative because they are machine-generated from the Standard.
+- **Human parameter descriptions** come from the RST man page `INPUT PARAMETERS` / `OUTPUT PARAMETERS` / `INPUT/OUTPUT PARAMETERS` bullets when present, falling back to the JSON `desc` field otherwise.
+
+### Extension APIs (RST-driven, best-effort)
+
+Open MPI extensions (`MPIX_*`, e.g. the ULFM `MPIX_Comm_*` and `MPIX_Query_*_support` families; and `OMPI_*`, e.g. `OMPI_Affinity_str`) have hand-written man pages and are **not** present in `pympistandard`. For these:
+
+- signature text is preserved **verbatim** from the RST `SYNTAX` code blocks;
+- structured per-parameter fields (`direction`, `kind`, `intent`) are set to `unknown` (or omitted) when they cannot be reliably extracted;
+- records still carry `name`, `kind: extension`, `languages`, human description, see-also, and URLs.
+
+The catalog therefore mixes high-fidelity standard records with best-effort extension records; the `kind` field lets consumers tell them apart.
+
+### Fortran interface model
+
+The catalog uses four language tags — `c`, `fortran_mpifh`, `fortran_use_mpi`, `fortran_mpi_f08` — and produces four language-specific Markdown corpora. However, `mpif.h` and `use mpi` **share the same `f90` signature**; they differ only in the access preamble (`INCLUDE 'mpif.h'` vs `USE mpi`). The spec keeps them as separate tags/corpora for audience clarity and future divergence, but implementers should expect the `fortran_mpifh` and `fortran_use_mpi` signatures to be identical apart from that preamble, both derived from the single `f90` binding.
+
+### Man page ↔ record mapping
+
+- A per-symbol Markdown page is generated for **every** MPI/MPIX/OMPI man page, 1:1 with the human man pages, so canonical URLs line up.
+- A JSONL catalog record is generated **per documented procedure**, not per page.
+- Some man pages document **multiple** procedures via the `.. mpi-bindings:` comment directive (for example, `MPI_Alltoallw.3.rst` carries `MPI_Alltoallw`, `MPI_Ialltoallw`, and `MPI_Alltoallw_init`). Each such procedure also has its own thin man page that `.. include::`s the primary page body, so each procedure has its own canonical HTML URL even though the prose is shared. Each procedure gets its own catalog record and its own `urls`, plus a `documented_with` field naming the co-documented procedures.
+- Some man pages are overviews or non-procedure pages (for example `MPI_T.3`, `Open-MPI.7`, `MPI_Errors.3`). These get a per-symbol Markdown page but **no** JSONL record.
+
+The Markdown generator must handle **arbitrary** RST section headings, not a fixed schema: real man pages contain sections such as `NOTE` vs `NOTES`, `USE OF IN-PLACE OPTION`, and `WHEN COMMUNICATOR IS AN INTER-COMMUNICATOR` in addition to the common ones.
+
+## Publication model
+
+Read the Docs supports serving a custom top-level `llms.txt` file from a project's default version, provided that the file exists in the HTML build output. Sphinx supports copying non-RST files into the HTML output with `html_extra_path`. Therefore Open MPI should publish:
+
+- a top-level `https://docs.open-mpi.org/llms.txt` from the default Read the Docs version (note: this follows whatever Read the Docs' *default* version is, which may be a series that does not yet carry these artifacts);
+- a versioned `llms.txt` in each public documentation version, such as `https://docs.open-mpi.org/en/<version>/llms.txt` (where `<version>` is the Read the Docs version slug, e.g. `v6.1.x` or `main`);
+- generated LLM artifacts below each versioned documentation tree, such as `https://docs.open-mpi.org/en/<version>/llms/...`.
+
+Each public documentation version emits a single, self-describing `llms.txt`; there is no separate hand-maintained top-level index file. The version-neutral `https://docs.open-mpi.org/llms.txt` is simply whatever the Read the Docs *default* version produced (which, per the note above, may be a series that does not yet carry these artifacts). Each versioned `llms.txt` therefore points to the artifacts of its own version and documents the `https://docs.open-mpi.org/en/VERSION_SLUG/` scheme so a consumer can reach any other version, rather than relying on a top-level index (the `llms.txt` section below details this).
+
+If Open MPI later needs different top-level behavior, Read the Docs exact redirects can be used to redirect `/llms.txt` to a chosen versioned path.
+
+The generated artifacts ride **inside** the per-version HTML output tree. The generator writes to a build-tree staging directory (`$(builddir)/llms-build/`), and a Sphinx `build-finished` hook in `conf.py` copies that tree into the HTML output (`app.outdir`) after the build. The copy is done in a Sphinx hook — rather than `html_extra_path` or a Makefile step — for two reasons: (1) the staged Markdown must be kept out of Sphinx source discovery via `exclude_patterns`, which would also suppress an `html_extra_path` entry pointing at it; and (2) the hook runs inside `sphinx-build`, so it works identically for `make` builds **and** for Read the Docs, which runs `sphinx-build` directly and never runs `make`. This is deliberate: riding the HTML output tree means the artifacts inherit the existing HTML distribution, installation, and packaging machinery (see [Build integration](#build-integration)) for free, and appear at `…/en/<version>/llms/…` automatically.
+
+The human-readable documentation should also expose these artifacts through a small, unobtrusive link from `docs/index.rst`. The front page is the right primary location because it is the highest-level public entry point for people, crawlers, and agents that browse ordinary documentation before checking `/llms.txt`. Avoid adding LLM-specific links to every manual page.
+
+## Artifact inventory
+
+Artifacts fall into two categories with different lifecycles:
+
+**Generated** (produced at build time; git-ignored like `html/`, `man/`, and `man-openmpi/man3/bindings/`; shipped in tarballs via the HTML tree copy):
+
+- **`llms.txt`** (versioned): the LLM entry point. A curated Markdown index, not the entire documentation payload.
+- **`llms/openmpi-mpi-api.jsonl`**: one JSON object per line describing public MPI API procedures and binding variants.
+- **`llms/openmpi-mpi-api.md`**: a single aggregate Markdown corpus for all public MPI APIs.
+- **`llms/openmpi-mpi-api-c.md`**: aggregate Markdown focused on the C interface.
+- **`llms/openmpi-mpi-api-fortran-mpifh.md`**: aggregate Markdown focused on the `mpif.h` interface.
+- **`llms/openmpi-mpi-api-fortran-use-mpi.md`**: aggregate Markdown focused on the `use mpi` interface.
+- **`llms/openmpi-mpi-api-fortran-use-mpi-f08.md`**: aggregate Markdown focused on the `use mpi_f08` interface.
+- **`llms/man-openmpi/man3/MPI_<name>.3.md`**: per-symbol Markdown pages generated from the corresponding RST manual pages.
+- **`llms/man-openmpi/man1/<command>.1.md`**: per-command Markdown pages generated from the section-1 (command) RST manual pages (`mpirun`, `ompi_info`, the wrapper compilers, ...). These document Open MPI commands, not MPI APIs, so they are a Markdown corpus only — there are **no** JSONL catalog records for them.
+- **`llms/openmpi-docs-manifest.json`**: a machine-readable inventory of the LLM artifacts in this documentation build.
+
+**Curated** (hand-written or lightly processed; committed to git):
+
+- **`llms/openmpi-mpi-examples.md`**: a curated set of small, validated MPI examples (see [Examples corpus](#examples-corpus)).
+- **`llms/openmpi-mpi-interface-guide.md`**: a concise guide for choosing among C, `mpif.h`, `use mpi`, and `use mpi_f08`.
+- **`llms/openmpi-runtime-introspection.md`**: a concise guide telling a consumer how to query an *installed* Open MPI with `ompi_info` — its version, build configuration, available MCA components, and the run-time MCA parameters those components expose, plus how to set MCA parameters (`--mca` / `OMPI_MCA_*` / parameter files). This installation-specific surface is intentionally **not** snapshotted into the corpus (see [Why no MCA-parameter snapshot](#why-no-mca-parameter-snapshot)).
+- **`llms/openmpi-mpi-api.schema.json`**: the JSON Schema for the API catalog records.
+- **`llms/openmpi-docs-manifest.schema.json`**: the JSON Schema for the manifest.
+
+(The curated source files live under `docs/` in git; the build copies them into the staging directory alongside the generated artifacts so all artifacts share one published location. The two `*.schema.json` files are both published artifacts and the CI validator — the published contract and the check are the same files.)
+
+## `llms.txt`
+
+The top-level `llms.txt` should be short and should link to the artifacts of the documentation version that produced it. On Read the Docs the links are absolute (slug-correct); in a local build they are relative (see the link-strategy reproducibility rule below). The version-neutral `https://docs.open-mpi.org/llms.txt` is served from the Read the Docs *default* version, which may be a series that does not yet carry these artifacts, so `llms.txt` explains the version-slug URL scheme itself rather than relying on the root being authoritative.
+
+Each versioned `llms.txt` should include:
+
+- project name and one-paragraph summary;
+- an "about this file" note identifying which build it belongs to — for a Read the Docs `main` build, naming **both** the `main` slug and the `vA.B.x` series it currently represents (dual attribution); for a local build, noting that it is a local, relative-link build;
+- the `https://docs.open-mpi.org/en/VERSION_SLUG/` scheme for locating other versions' LLM docs (`main` = the main-branch build, `vA.B.x` = a release branch, `vA.B.C` = a specific tagged release), worded so an LLM that wants a different version can construct the URL, plus a pointer that pre-v5.0.0 documentation lives at the legacy README / FAQ / doc pages. These scheme-documentation URLs are always literal absolute `docs.open-mpi.org` text, even in a local build, so a local consumer still learns where the published versions live;
+- a note that the MPI Standard is authoritative for portable MPI semantics;
+- a note that `MPIX_*` and `OMPI_*` APIs are Open MPI extensions;
+- links to the API catalog, Markdown corpora, examples, and interface guide;
+- links to the command (man1) pages and to key human-facing guides such as building, launching, and tuning MPI applications.
+
+## Markdown API corpus
+
+The aggregate Markdown corpora should be generated files derived from the same source RST manual pages used for the human documentation. They should be plain Markdown, with Sphinx-only syntax resolved or removed.
+
+These files should preserve the important content from the manual pages:
+
+- API name and short description;
+- syntax for the relevant interface set;
+- input, output, and input/output parameter sections;
+- description, notes, errors, and see-also links;
+- a canonical URL for the human HTML page;
+- the source RST path.
+
+They should omit Sphinx navigation, theme chrome, raw unresolved directives, duplicate index material, and generated boilerplate that does not help a tool understand or use the API.
+
+The four language-specific corpora partition the same content by interface. Because `mpif.h` and `use mpi` share signatures, those two corpora will be near-duplicates apart from the access preamble and any interface-specific notes; this is expected and acceptable.
+
+## Per-symbol Markdown pages
+
+The per-symbol Markdown pages should be stripped-down, include-expanded versions of the same manual-page content, not merely raw RST renamed to `.md`. They should match the human manual page semantically, but be normalized for machine consumption.
+
+For example, `MPI_Send.3.md` should contain the `MPI_Send` short description, C and Fortran syntax, parameter descriptions, notes, errors, and see-also links. It should not contain unresolved `.. include::` directives, `:ref:` roles, or Sphinx-only substitution syntax.
+
+Because each documented procedure has its own man page (secondaries `.. include::` the primary), the generator produces one `.md` per page with the include fully expanded, so a tool fetching a secondary page such as `MPI_Ialltoallw.3.md` receives the complete shared content rather than an unresolved include.
+
+## Machine-readable API catalog
+
+`openmpi-mpi-api.jsonl` should contain one JSON object per public MPI API documentation record. Each record should be self-contained enough for a tool to answer signature, parameter, language-interface, and documentation-link questions without scraping Markdown.
+
+The catalog uses a `schema_version` independent of the Open MPI release number, so the JSON schema can evolve while the Open MPI release series remains the same.
+
+Required top-level fields:
+
+- **`schema_version`**: version of the JSONL record schema, such as `1`.
+- **`project`**: always `open-mpi` for this catalog.
+- **`docset`**: object describing the documentation build. It contains the Open MPI version derived from the top-level `VERSION` file and the `schema_version`. It does **not** carry build-identity fields (see [Build identity and reproducibility](#build-identity-and-reproducibility)); those live only in the manifest.
+- **`name`**: primary API name, such as `MPI_Send`.
+- **`kind`**: one of `standard`, `extension`, `deprecated`, or `removed`.
+- **`standard`**: object describing MPI Standard version information when known.
+- **`category`**: API family such as `point-to-point`, `collective`, `communicator`, `datatype`, `rma`, `io`, `sessions`, or `tools`.
+- **`languages`**: the set of interfaces for which this record provides bindings — exactly the distinct `language` values across `bindings` (a subset of `c`, `fortran_mpifh`, `fortran_use_mpi`, and `fortran_mpi_f08`). For a fully-generated standard-API record this is all four; a partial record lists only what it carries.
+- **`bindings`**: array of binding variants. Each variant includes language, procedure name, rendered signature, parameters, return convention, and whether it is a large-count variant.
+- **`parameters`**: normalized parameter metadata where it can be obtained reliably: name, direction, type, intent, optionality, and description. For extension records, structured fields may be `unknown`.
+- **`semantics`**: object containing optional fields such as `blocking`, `collective`, `local`, `initialization_required`, and `threading_notes` when known.
+- **`errors`**: object describing the error-return convention and a link to the human error-handling documentation.
+- **`seealso`**: array of related API names.
+- **`documented_with`**: array of co-documented procedure names when the API shares a man page with others (empty or absent otherwise).
+- **`urls`**: object containing canonical HTML and Markdown URLs for **this** procedure's own page.
+- **`sources`**: object containing source RST paths and generated binding metadata sources.
+
+Every field above is always present in a record (so consumers need not handle missing keys), with one exception and one refinement: `documented_with` may be omitted when empty, and the when-known fields (`standard`, `category`, `parameters`, `semantics`, `errors`) are set to `null` or an empty array for best-effort/extension records rather than dropped. This is exactly the `required` set of the published JSON Schema, so the prose list and the machine-checkable contract agree.
+
+A record is therefore locatable from its own `urls` and `docset.ompi_version` alone; build provenance (which commit produced it, when) is intentionally **not** embedded per-record but is available once per build in the manifest. This is the deliberate trade-off that keeps per-artifact content hashes a function of semantic content only.
+
+The catalog records conform to a published JSON Schema, `openmpi-mpi-api.schema.json` (and the manifest to `openmpi-docs-manifest.schema.json`). These schema files are authored as the formal contract, published as artifacts, and reused directly by CI as the validator, so the published structural contract and the check can never drift apart. Cross-field invariants that plain JSON Schema cannot express — for example, that a record's `languages` equals the distinct set of its `bindings[].language` — are enforced by additional CI checks layered on top of schema validation. The JSON Schema is versioned in step with `schema_version` / `artifact_schema_version`.
+
+The spec should ship sample records (in this `specs/` directory or a fixture) for `MPI_Init`, `MPI_Send`, `MPI_Allreduce`, `MPI_Alltoallw` (multi-procedure, large-count), and one `MPIX_*` extension, and CI should check that the samples validate against the JSON Schema.
+
+## Build identity and reproducibility
+
+Open MPI is already a reproducible-builds-aware project: `config/getdate.sh` honors `SOURCE_DATE_EPOCH`, the release notes instruct users to set `SOURCE_DATE_EPOCH`/`USER`/`HOSTNAME` for reproducible builds, and `config/opal_get_version.sh` derives the repo revision from `git describe --tags --always` (falling back to a date when there is no `.git`). Sphinx's own `html_last_updated_fmt` footer also honors `SOURCE_DATE_EPOCH`. The LLM artifacts must fit this existing model rather than invent a new one.
+
+### Versioning
+
+The Open MPI version in each record and in the manifest must be derived from the top-level `VERSION` file, following the same rules already used by `docs/conf.py`. When building on Read the Docs, the published documentation path may use the Read the Docs version slug, but the Open MPI release metadata still comes from `VERSION`.
+
+### Build-identity fields are manifest-only
+
+The following fields change between builds and are written **only in the manifest** — never inside the catalog records, Markdown corpora, or per-symbol pages:
+
+- **`git_commit`**: the source commit used for the documentation build, when available.
+- **`git_describe`**: `git describe --tags --always` output, when available.
+- **`generated_at`**: UTC timestamp for the artifact generation.
+
+Rationale: if `git_commit` were embedded in every catalog record, then every artifact's content hash would change on every commit to the repository — even a commit that touches no documentation — which would make the manifest's per-artifact hashes useless as change detectors. By keeping build identity in the manifest only, each artifact's hash is a pure function of its semantic content, so "hash changed ⇔ documentation content changed." (`schema_version` and `artifact_schema_version` are treated as semantic: a schema bump legitimately changes everything.)
+
+### Reproducibility rules
+
+- **Timestamp.** `generated_at` is derived from `SOURCE_DATE_EPOCH` when set (UTC), exactly as `getdate.sh` and Sphinx's `format_date` do; otherwise it falls back to the build commit date, then to wall-clock time. CI and `make dist` set/derive `SOURCE_DATE_EPOCH`.
+- **Semantic artifacts are wall-clock-free.** The catalog, corpora, and per-symbol pages contain no timestamp, so they are byte-identical across reruns at a given commit, regardless of `SOURCE_DATE_EPOCH`.
+- **Content hashing.** Manifest content hashes are computed over the (wall-clock-free) artifact bytes.
+- **Stable ordering.** All collections (records, parameters, see-also, file listings) are emitted in a deterministic order.
+- **Link strategy: local builds are relative, Read the Docs builds are absolute.** A local build from git produces the artifacts for a *local* LLM/tool that reads the files straight off disk; there is no docs.open-mpi.org site in play, so the RTD URL scheme is irrelevant and every generated link — in `llms.txt`, the JSONL record `urls`, the manifest `url`s, and the per-symbol/man1 page Canonical-HTML headers — is made **relative to the file that contains it**, yielding a self-contained, portable tree. A Read the Docs build publishes under `https://docs.open-mpi.org/en/<slug>/`, so there every link is **absolute** and uses the published version slug (`…/en/main/…` for the `main` branch, `…/en/v6.1.x/…` for a release branch, `…/en/v6.1.0/…` for a tagged release). The base is resolved in this order: an explicit `--url-base`/`OMPI_LLM_URL_BASE` override (absolute); then `READTHEDOCS_CANONICAL_URL` / `READTHEDOCS_VERSION` (absolute, slug-correct); otherwise relative (local). Determinism is "same source + same environment ⇒ no diff"; the determinism check runs both passes in one environment, so the strategy and slug are constant across them. Exception: the version-slug *scheme-documentation* URLs printed inside `llms.txt` are always literal absolute `docs.open-mpi.org` text, in every build, so a local consumer still learns where the published versions live.
+- **Graceful degradation.** In a from-tarball build with no `.git` and no `SOURCE_DATE_EPOCH`, the generator must not fail: git fields become `unknown`/omitted and `generated_at` falls back to the tarball/build date, mirroring `opal_get_version.sh`.
+
+A determinism check (see [Build integration](#build-integration)) reruns the generator at a fixed `SOURCE_DATE_EPOCH` and commit and asserts no file diffs.
+
+### Reproducible human-docs fix (folded in)
+
+While adopting `SOURCE_DATE_EPOCH`, this effort also closes a small pre-existing reproducibility gap in the human docs build: `docs/conf.py` currently computes the copyright year with `datetime.datetime.now().year`, which ignores `SOURCE_DATE_EPOCH`. This makes the copyright string and the `|year|` RST substitution non-reproducible even on the documented reproducible-build path. The fix derives `year` from `SOURCE_DATE_EPOCH` when set, falling back to `datetime.now()` otherwise. As part of this, verify that the Sphinx "Last updated on:" HTML footer is reproducible under `SOURCE_DATE_EPOCH` (it is, via `format_date`) and check the man-page `.TH` date for the same property. The result is a docs build (HTML, man, and LLM artifacts) that is fully reproducible under a single, already-documented knob.
+
+## Chunk manifest
+
+`openmpi-docs-manifest.json` is an inventory for retrieval systems. It lets consumers decide what to fetch, cache, or refresh without guessing from filenames. It is the single place that carries build identity.
+
+The manifest should include:
+
+- manifest schema version (`artifact_schema_version`);
+- Open MPI version derived from `VERSION`;
+- Read the Docs version slug when available;
+- `git_commit`, `git_describe`, and `generated_at` (the only build-identity fields in any artifact);
+- one entry per generated and curated artifact, **except the manifest itself**;
+- URL, local path, media type, content hash, byte size, and estimated token count for each artifact;
+- symbol names covered by each artifact, when applicable;
+- language/interface set covered by each artifact, when applicable.
+
+The manifest does not inventory itself: a file cannot record its own content hash and byte size (writing them changes both), and the manifest is the one artifact that is intentionally not wall-clock-free. Every other artifact — including the versioned `llms.txt` — is listed. For this to hold, the versioned `llms.txt` header must itself be timestamp-free (it carries the Open MPI version, not a generation time); build provenance for the whole set lives once, in the manifest.
+
+The manifest does not require an independently incremented documentation release number. Instead, consumers compare manifest identity fields and artifact content hashes. For example, if the `v6.1.x` branch receives a documentation fix before a `v6.1.1` release, the Open MPI release value may remain unchanged, but the manifest's git identity and the hashes of the *affected* artifacts will change, while unaffected artifacts' hashes stay the same.
+
+## Shared generator infrastructure
+
+The implementation should share infrastructure with `docs/generate-mpi-man3-bindings.py` rather than creating unrelated parsers.
+
+At minimum, the shared infrastructure should provide:
+
+- parsing of MPI manual-page directives such as `.. mpi-bindings:` (a single-colon comment line, parsed textually, not a registered Sphinx directive);
+- loading of `pympistandard` (from the embedded `3rd-party/pympistandard/src`) and `mpi-standard-apis.json`;
+- generation of C and Fortran binding strings (C `iso_c`, fixed-form `f90`, and `f08`, plus large-count "embiggened" variants);
+- a separate path for extracting extension signatures from hand-written RST `SYNTAX` blocks;
+- parsing of the top-level `VERSION` file;
+- build-identity helpers for `git_commit` / `git describe --tags --always` and `SOURCE_DATE_EPOCH`-aware timestamps;
+- common handling for primary API pages that document multiple MPI procedures.
+
+One possible implementation is to extract common code into a helper module under `docs/` and have both `generate-mpi-man3-bindings.py` and the LLM artifact generator import it. The helper must remain compatible with Open MPI's supported Python version floor, which is **3.6** (per `python_min_version` in `VERSION`). Avoid importing `docs/conf.py` directly for version parsing if doing so would trigger Sphinx configuration side effects; factor the `VERSION` parser so both can share it without importing Sphinx config.
+
+## Examples corpus
+
+`openmpi-mpi-examples.md` is a curated artifact. Its purpose is representative coverage, not exhaustive API coverage.
+
+To honor the "avoid a second hand-maintained reference" goal, **reuse the existing top-level `examples/` directory where it already covers a case**, rather than authoring parallel copies. `examples/` already contains:
+
+- `hello_*` — minimal initialize/finalize, in C, `mpif.h` (`hello_mpifh.f`), `use mpi` (`hello_usempi.f90`), and `use mpi_f08` (`hello_usempif08.f90`);
+- `ring_*` — point-to-point send/receive, in the same four interfaces;
+- an `examples/Makefile` that already compiles them with the Open MPI wrapper compilers.
+
+Recommended approach: source/generate the Markdown for the covered cases from those files, and wire CI compilation through the existing `examples/Makefile` (which gets "compile in CI" nearly for free). Hand-author only the genuine gaps:
+
+- collective communication;
+- nonblocking communication;
+- derived datatypes;
+- communicators;
+- MPI-IO;
+- RMA.
+
+The corpus must include at least one example for each supported Fortran interface set (the reused `hello_*`/`ring_*` files already provide this). Examples should use the Open MPI wrapper compilers (`mpicc`, `mpifort`). Where practical, examples should be compiled or otherwise validated in CI; the spec should record which examples are compiled and which are documentation-only.
+
+## Interface guide
+
+`openmpi-mpi-interface-guide.md` is a concise guide that helps tools choose the correct interface for generated code. It should state:
+
+- prefer `use mpi_f08` for new Fortran code when available;
+- `mpif.h` and `use mpi` exist for legacy code, and share the same procedure signatures (differing only in `INCLUDE 'mpif.h'` vs `USE mpi`);
+- C large-count variants use `_c` names where provided by MPI;
+- `MPIX_*` and `OMPI_*` APIs are Open MPI extensions and are not portable MPI Standard APIs;
+- applications should normally use `mpicc`, `mpicxx`, and `mpifort` rather than invoking the underlying compiler and linker flags manually.
+
+## Runtime introspection guide
+
+`openmpi-runtime-introspection.md` is a concise curated guide telling a consumer how to query an *installed* Open MPI with the `ompi_info` command. It covers:
+
+- detecting the Open MPI version and MPI standard level, and the build configuration (`ompi_info --version`, `ompi_info`, `ompi_info --parsable`);
+- listing the MCA components present in this build;
+- enumerating the run-time MCA parameters comprehensively with `ompi_info --all --parsable`, and reading the self-describing `mca:<framework>:<component>:param:<name>:<field>:<value>` output;
+- setting MCA parameters, with concrete examples for the command line (`mpirun/mpiexec --mca`), the environment (`OMPI_MCA_*`), and parameter files, in precedence order.
+
+It is the corpus's answer to a discoverability gap surfaced in review: a consumer reading the API artifacts has no signal that the MCA surface (and the live build configuration) is queryable at run time. The guide closes that gap by pointing at the authoritative command rather than duplicating its output.
+
+### Why no MCA-parameter snapshot
+
+The same review suggested *maybe* committing an `ompi_info --all --parsable` snapshot as an artifact. This is intentionally **not** done:
+
+- The output is **installation-specific**: it reflects exactly which components a given build compiled in, and is full of machine-specific values (install `prefix`, config command line, compiler paths, host name). A committed snapshot would bake in one machine's reality and be misleading on every other installation.
+- It would **immediately drift** from any installation that differs in version, configure options, or available hardware/components.
+- It **cannot be produced at docs-build time**: Read the Docs (and a docs-only checkout) builds the documentation without a full Open MPI installation, so there is no `ompi_info` to run. Embedding a snapshot would also violate the "derived from the documentation sources, never independently authored" principle.
+
+The discoverability fix is therefore guidance (run the self-describing command against the live installation), not a catalog or snapshot.
+
+## Build integration
+
+Generated artifacts are created as part of the documentation build. The generator writes them (and copies the curated sources) into a build-tree staging directory (`$(builddir)/llms-build/`). It is run in **both** build paths, mirroring how `generate-mpi-man3-bindings.py` is run: for `make` builds, from a sentinel target in `BUILT_SOURCES` (after the man3 bindings, before Sphinx); for Read the Docs builds — which run `sphinx-build` directly and never run `make` — from `.readthedocs-pre-create-environment.sh`. A `build-finished` hook in `conf.py` then copies the staging tree (`llms-build/llms` → `<output>/llms`, `llms-build/llms.txt` → `<output>/llms.txt`) into the Sphinx HTML output, replacing any prior copy so it matches the staged tree. Because the copy lives in the Sphinx hook, it happens under `make` and on Read the Docs alike, and the artifacts are published with the rest of the versioned documentation.
+
+Because the artifacts ride inside the HTML output tree, they inherit the existing HTML machinery:
+
+- the `html-local` target already copies `_build/html` into `docs/html/`, which is in `EXTRA_DIST`, so the artifacts ship in release tarballs automatically;
+- `install-data-hook` already installs the entire `html` tree under `$(docdir)`, so the artifacts install with no new install rule;
+- `uninstall-hook` already removes `$(docdir)` recursively, so no new uninstall rule is needed.
+
+This means the bulk of distribution/installation work is already handled; the new Automake work is mostly: invoking the generator, declaring its source/build directories (with VPATH-safe output to the build tree), declaring curated source files in `EXTRA_DIST`, and ensuring `make distcheck` passes.
+
+Open MPI distribution tarballs already include pre-rendered HTML and man pages so end users do not need Sphinx installed. The LLM artifacts follow the same convention: a tarball ships the already-rendered `llms/` tree inside `html/`. If `configure` did not find Sphinx, or if the rendered artifacts are already present and do not need regeneration, `make` must not require Sphinx merely to preserve, install, or package the pre-rendered LLM artifacts. In a developer Git clone without usable pre-rendered artifacts, generating or refreshing them may require the same Sphinx/documentation-tooling prerequisites as the rest of the docs build, and should fail with a clear message when that tooling is unavailable.
+
+The human-facing docs should include either a one-sentence entry in the `docs/index.rst` documentation-locations area, or a short `docs/llm-friendly-docs.rst` landing page linked from `docs/index.rst` if more explanation is needed. The landing page, if added, should link to `/llms.txt`, the versioned `llms.txt`, the generated API catalog, the Markdown corpora, and the manifest.
+
+The generated output is deterministic except for the explicitly documented manifest-only build-identity fields. CI verifies that generated artifacts are up to date by rerunning the generator (at a pinned `SOURCE_DATE_EPOCH`, commit, and URL base) and asserting no file diffs.
+
+## Validation expectations
+
+CI should validate, at minimum: that each catalog record validates against the published `openmpi-mpi-api.schema.json` and the manifest against `openmpi-docs-manifest.schema.json` (this covers JSONL syntax, required fields, and allowed enum values such as `project`, `kind`, `category`, and `languages`); that each record's `languages` equals the distinct set of its `bindings[].language` (a cross-field invariant beyond JSON Schema); that every record links back to the human documentation; that every Markdown file is free of unresolved `.. include::` directives, `:ref:` roles, and Sphinx-only substitutions; that manifest hashes, byte sizes, and entry coverage match the artifacts; that every artifact referenced by `llms.txt` exists; that the sample records validate against the JSON Schema; and the determinism (no-diff) rerun.
+
+## Release and maintenance process
+
+### Schema evolution and compatibility
+
+- **Additive within a `schema_version`.** New fields must be optional; existing consumers must keep working. A field may be marked deprecated (but is still emitted) for one Open MPI release series before it is removed. Never remove, rename, repurpose, or change the meaning of an existing field without a version bump. So that an additive field does not break a consumer validating against an older cached copy of the schema, the published JSON Schemas use open objects (they do not set `additionalProperties: false`); an unknown future field is tolerated rather than rejected.
+- **Bump on breaking change only.** `schema_version` (catalog) and `artifact_schema_version` (manifest) increment only when a non-additive change lands — not on every release. The decision is owned by the docs maintainers and recorded in the schema documentation that ships with the catalog.
+
+### Changelog and release notes
+
+- A `schema_version`/`artifact_schema_version` bump or a notable field change gets an entry in `docs/release-notes/changelog/vMAJOR.MINOR.x.rst`.
+- The artifacts themselves get a **single** release note when first shipped (they are user-visible in installed documentation).
+- Routine regeneration — content that flows automatically from changed RST or metadata — does **not** get changelog entries; consumers detect those changes via the manifest's identity fields and per-artifact hashes.
+
+### Keeping curated docs in sync
+
+Generated artifacts regenerate automatically from RST/metadata, so they cannot drift. The curated docs (interface guide, examples) can. The expectation — documented in both the developer docs and `AGENTS.md` — is that a pull request changing public MPI documentation should also update the affected curated LLM docs when relevant (for example, adding an example or a guide note for a newly documented API). A lightweight CI **drift hint** (not a hard gate) for likely gaps — such as a new man page with no catalog coverage, or an interface-guide/example reference to a removed symbol — is envisioned as follow-on work but is **not yet implemented**. The current validator checks that the manifest inventories every on-disk artifact, but does not check procedure-to-record coverage or curated-symbol references, so such gaps are currently silent.
+
+### Release-time regeneration
+
+Release managers already set `SOURCE_DATE_EPOCH` (and `USER`/`HOSTNAME`) when producing reproducible release tarballs. Because the generator honors `SOURCE_DATE_EPOCH` automatically, **no separate regeneration step is required** of the release manager; the LLM artifacts are produced by the normal docs build. This dependency is documented in `docs/developers/llm-friendly-docs.rst`.
+
+### Verifying publication
+
+After a merge that affects the artifacts, a documented manual spot-check confirms publication: fetch the merged version's own `llms.txt` (for example `https://docs.open-mpi.org/en/main/llms.txt` for the `main` branch) and one versioned artifact (for example the manifest) and confirm they resolve and parse. The version-neutral `https://docs.open-mpi.org/llms.txt` follows Read the Docs' default version, which may not yet carry these artifacts, so the spot-check targets the specific version slug just published. No new publication infrastructure is added.
+
+## Follow-on work
+
+- Extend the same artifact model to OpenSHMEM public APIs (adding OpenSHMEM-specific schema examples first) — **deferred until there is concrete demand**.
+
+(Earlier candidates that were explicitly considered and dropped: an `llms-full.txt` full-payload entry point, compressed downloadable bundles, and stable redirects for renamed artifacts. The aggregate corpora, release tarballs/manifest, and ad hoc Read the Docs redirects respectively make these unnecessary. JSON Schema files were promoted into current scope.)
diff --git a/specs/llms-friendly-docs/tasks.md b/specs/llms-friendly-docs/tasks.md
new file mode 100644
index 00000000000..990b7e555d9
--- /dev/null
+++ b/specs/llms-friendly-docs/tasks.md
@@ -0,0 +1,213 @@
+# LLM-friendly documentation task list
+
+This task list tracks implementation of the LLM-friendly documentation artifacts described in [spec.md](spec.md).
+
+Locked decisions (see spec for rationale):
+
+- **Fortran model:** four language tags/corpora (`c`, `fortran_mpifh`, `fortran_use_mpi`, `fortran_mpi_f08`); `mpif.h` and `use mpi` share the `f90` signature and differ only in the access preamble.
+- **Extensions:** include both `MPIX_*` and `OMPI_*`; best-effort fidelity (verbatim signature text, `unknown` structured params when not extractable).
+- **Determinism:** honor `SOURCE_DATE_EPOCH`; build-identity fields (`generated_at`, `git_commit`, `git_describe`) live in the manifest **only**; semantic artifacts are wall-clock-free; content hashes are over semantic bytes.
+- **Storage:** generated artifacts are git-ignored and ride the HTML output tree (`_build/html/llms/`); curated sources (interface guide, examples) are committed.
+
+## Phase 0: repository and build-system survey
+
+- [x] Inventory the existing MPI man-page source files under `docs/man-openmpi/man3/` (612 MPI man pages listed in `OMPI_MAN3`).
+- [x] Inventory the generated MPI binding include files under `docs/man-openmpi/man3/bindings/` (git-ignored, generated to the build tree).
+- [x] Inventory existing man pages that document multiple MPI procedures via `.. mpi-bindings:` (57 directives).
+- [x] Inventory the extension man pages (`MPIX_*`, `OMPI_Affinity_str`) and confirm they are absent from `pympistandard` (11 `MPIX_*` + `OMPI_Affinity_str`; signatures only in hand-written RST).
+- [x] Inventory the secondary-procedure stub pages (e.g. `MPI_Ialltoallw.3.rst`) that `.. include::` a primary page body (`:start-after: .. include_body`).
+- [x] Inventory overview/non-procedure man pages (e.g. `MPI_T.3`, `Open-MPI.7`, `MPI_Errors.3`) that will get Markdown but no JSONL record.
+- [x] Identify all current documentation build modes in `docs/Makefile.am`: developer tree with Sphinx (`OPAL_BUILD_DOCS`), release tarball with pre-rendered docs, and build without Sphinx.
+- [x] Confirm the existing HTML lifecycle that the artifacts will ride: `html-local` copy into `docs/html/`, `EXTRA_DIST` inclusion, `install-data-hook`, `uninstall-hook`.
+- [x] Decide where generated LLM artifacts live: git-ignored, written to a build-tree staging directory and copied into `_build/html/llms/` by a `conf.py` `build-finished` hook (not `html_extra_path` — see Phase 5), shipped via the HTML tree copy. Curated sources committed under `docs/llms-src/`. *(Decided.)*
+
+## Phase 1: schema and format design
+
+- [x] Define `openmpi-mpi-api.jsonl` schema version 1.
+- [x] Define the `docset` object as **semantic-only**: Open MPI version (from `VERSION`) and `schema_version`. Explicitly exclude build-identity fields (those live in the manifest).
+- [x] Define `project` as the literal value `open-mpi`.
+- [x] Define allowed `kind` values and rules for assigning `standard`, `extension`, `deprecated`, and `removed`.
+- [x] Define allowed `category` values and rules for assigning APIs to categories.
+- [x] Define allowed `languages` values: `c`, `fortran_mpifh`, `fortran_use_mpi`, and `fortran_mpi_f08`.
+- [x] Define the `bindings` object shape, including language, procedure name, signature text, large-count marker, return convention, and parameter list. Note that `fortran_mpifh` and `fortran_use_mpi` share the `f90` signature, differing only in preamble.
+- [x] Define the normalized `parameters` object shape (name, direction, datatype, intent, optionality, human description) and the **source-of-truth rule**: structured fields from `mpi-standard-apis.json`/`pympistandard`; human description from RST `INPUT/OUTPUT PARAMETERS` bullets, falling back to JSON `desc`.
+- [x] Define how extension records represent unreliable structured fields (`unknown` / omitted) while preserving verbatim signature text.
+- [x] Define the `semantics` object fields that can be filled reliably from existing documentation and metadata.
+- [x] Define URL fields for canonical HTML, per-symbol Markdown, aggregate Markdown, and source RST paths.
+- [x] Define the `documented_with` field for procedures that share a man page.
+- [x] Define how to represent man pages that document multiple related procedures (one record per procedure; own URLs; `documented_with` cross-links).
+- [x] Define how to represent large-count `_c` variants and Fortran generic interfaces.
+- [x] Define how to represent Open MPI extension symbols (`MPIX_*`, `OMPI_*`).
+- [x] Define how missing or uncertain metadata should be omitted, set to `null`, or marked as `unknown`.
+- [x] Create sample JSONL records for `MPI_Init`, `MPI_Send`, `MPI_Allreduce`, `MPI_Alltoallw`, and one `MPIX_*` extension (`specs/llms-friendly-docs/sample-records.jsonl`; validated against the schema).
+- [x] Define the per-symbol Markdown page structure (handles **arbitrary** section headings, not a fixed set).
+- [x] Define the aggregate Markdown structure for all APIs.
+- [x] Define the aggregate Markdown structure for each language/interface-specific corpus.
+- [x] Define the manifest JSON schema, including the manifest-only build-identity fields and per-artifact metadata.
+- [x] Author the published JSON Schema files — `openmpi-mpi-api.schema.json` (catalog) and `openmpi-docs-manifest.schema.json` (manifest) — versioned with `schema_version`/`artifact_schema_version`, to serve as both the formal contract and the CI validator.
+- [x] Define content-hash, byte-size, and token-estimate rules for manifest entries (hash computed over wall-clock-free semantic bytes).
+- [x] Define how `generated_at` is handled: `SOURCE_DATE_EPOCH`-derived, manifest-only, semantic artifacts wall-clock-free. *(Decided.)*
+
+## Phase 2: shared MPI metadata infrastructure
+
+- [x] Extract common helper code from `docs/generate-mpi-man3-bindings.py` where practical (new `docs/ompi_docs_common.py`).
+- [x] Preserve `docs/generate-mpi-man3-bindings.py` behavior while moving shared logic (byte-identical bindings output verified via before/after diff; full clean docs build succeeds).
+- [x] Add shared parsing for `.. mpi-bindings:` directives (single-colon comment, parsed textually).
+- [x] Add shared discovery of primary MPI man pages and secondary MPI procedures documented on those pages.
+- [x] Add shared loading of `pympistandard` from the embedded `3rd-party/pympistandard/src` tree.
+- [x] Add shared loading of `docs/mpi-standard-apis.json`.
+- [x] Add shared rendering of C binding strings (`iso_c`).
+- [x] Add shared rendering of `mpif.h` / `use mpi` binding strings (the shared `f90` string + per-interface preamble).
+- [x] Add shared rendering of `use mpi_f08` binding strings (`f08`).
+- [x] Add shared detection of large-count ("embiggened") binding variants.
+- [~] Add a shared extension-signature extractor that reads hand-written RST `SYNTAX` code blocks for `MPIX_*`/`OMPI_*` pages. *(Deferred to Phase 3, where the RST resolver is built and the exact shape is known.)*
+- [x] Add shared parsing of the top-level `VERSION` file (without importing `docs/conf.py` / triggering Sphinx side effects).
+- [x] Add shared build-identity helpers: `git_commit`, `git describe --tags --always`, and a `SOURCE_DATE_EPOCH`-aware UTC timestamp (with graceful no-`.git`/no-epoch fallback, mirroring `opal_get_version.sh`).
+- [x] Keep all new Python compatible with the Python 3.6 floor (`python_min_version` in `VERSION`); the module uses `str.format` and standard-library APIs available in 3.6.
+- [~] Add focused tests or fixtures for shared metadata helpers where practical. *(Smoke-tested; the formal test harness is added in Phase 7.)*
+
+## Phase 3: LLM artifact generator
+
+- [x] Add a generator script for LLM-friendly docs (`docs/generate-llm-docs.py`).
+- [x] Give the generator explicit `--srcdir`, `--builddir`, and output-directory options consistent with existing docs generators.
+- [x] Add a `--url-base` option (or environment-derived setting) for the public documentation URL base; default to the `VERSION`-derived series path so URLs are stable across local and Read the Docs builds.
+- [x] Generate `llms/openmpi-mpi-api.jsonl` (standard records metadata-driven; extension records best-effort from RST) — 512 records (501 standard + 11 extension), all schema-valid.
+- [x] Generate per-symbol Markdown under `llms/man-openmpi/man3/` (one per man page; includes fully expanded) — 525 pages.
+- [x] Generate `llms/openmpi-mpi-api.md`.
+- [x] Generate `llms/openmpi-mpi-api-c.md`.
+- [x] Generate `llms/openmpi-mpi-api-fortran-mpifh.md`.
+- [x] Generate `llms/openmpi-mpi-api-fortran-use-mpi.md`.
+- [x] Generate `llms/openmpi-mpi-api-fortran-use-mpi-f08.md`.
+- [x] Generate `llms/openmpi-docs-manifest.json` (the only artifact carrying build identity).
+- [x] Copy curated source artifacts (interface guide, examples, and the two `*.schema.json` files) into the output `llms/` tree so all artifacts share one location (copy mechanism in place; schemas present now, guide/examples land in Phase 4).
+- [x] Generate a versioned `llms.txt` for the current documentation build.
+- [~] Generate or stage a top-level `llms.txt` suitable for the Read the Docs default version. *(The versioned `llms.txt` at the staging root is what RTD serves at the version root and, for the default version, at `/`. A `/llms.txt` redirect is an available RTD-side option if needed — see Phase 5.)*
+- [x] Resolve `.. include::` directives needed by per-symbol Markdown pages (including secondary-page includes of primary bodies).
+- [x] Resolve common Sphinx roles such as `:ref:` into readable Markdown links or plain text (including multi-line roles and RST hyperlinks).
+- [x] Resolve common Sphinx substitutions used in MPI man pages.
+- [x] Handle arbitrary RST section headings, not just a fixed set.
+- [x] Preserve code blocks with correct language tags where possible.
+- [x] Preserve see-also relationships as symbol names and links.
+- [x] Exclude Sphinx navigation, theme content, duplicate index content, and unresolved directives from generated Markdown (verified: zero unresolved `:ref:`/include/directive/substitution/hyperlink across all 525 pages).
+- [x] Keep semantic artifacts wall-clock-free; write build identity only in the manifest (verified deterministic: byte-identical reruns at fixed `SOURCE_DATE_EPOCH`).
+- [x] Ensure generated files are written only when content changes.
+- [x] Ensure generated output ordering is stable across runs.
+- [x] Emit make-style status messages consistent with existing docs generators.
+- [x] Add the shared extension-signature extractor for `MPIX_*`/`OMPI_*` pages (`extension_bindings_from_rst`; deferred from Phase 2).
+
+## Phase 4: curated source artifacts
+
+- [x] Write `llms/openmpi-mpi-interface-guide.md` (committed source `docs/llms-src/openmpi-mpi-interface-guide.md`).
+- [x] Explain when generated code should choose C.
+- [x] Explain when generated code should choose `use mpi_f08`.
+- [x] Explain legacy status and shared-signature relationship of `mpif.h` and `use mpi`.
+- [x] Explain wrapper compiler usage: `mpicc`, `mpicxx`, and `mpifort`.
+- [x] Explain that `MPIX_*` and `OMPI_*` symbols are Open MPI extensions, not portable MPI Standard APIs.
+- [x] Explain large-count `_c` variants and when to use them.
+- [x] Write `llms/openmpi-mpi-examples.md` (committed source `docs/llms-src/openmpi-mpi-examples.md`).
+- [x] Reuse the existing top-level `examples/` files for covered cases (hello = init/finalize; ring = point-to-point) across C, `mpif.h`, `use mpi`, and `use mpi_f08`, rather than authoring parallel copies.
+- [x] Hand-author the gap examples: collective, nonblocking, derived datatype, communicator, MPI-IO, and RMA.
+- [x] Ensure at least one example per supported Fortran interface set (covered by the reused `hello_*`/`ring_*` files).
+- [x] Include compile commands using Open MPI wrapper compilers.
+- [x] Decide and record which examples are compiled in CI: the canonical `examples/` `hello_*`/`ring_*` programs are compiled via `examples/Makefile`; the additional C examples in the corpus are compile-checked (verified here with `mpicc -Wall`, all 8 C blocks build) and documented as documentation examples.
+
+## Phase 5: Sphinx, Automake, and Read the Docs integration
+
+- [x] Have the generator write artifacts (and copy curated sources) into a build-tree staging directory (`$(builddir)/llms-build/`). *(Published by a `build-finished` hook in `conf.py` that copies the staging tree into the Sphinx HTML output — NOT `html_extra_path` (which `exclude_patterns` would suppress) and NOT a Makefile step (Read the Docs never runs `make`). The generator runs from the Makefile sentinel for `make` builds and from `.readthedocs-pre-create-environment.sh` for RTD; the conf.py hook publishes in both.)*
+- [x] Add the generator to `docs/Makefile.am` with correct source/build directory handling and a sentinel target (`SENTINEL_OMPI_LLM`, a dep of `$(ALL_MAN_BUILT)` in `BUILT_SOURCES`) that runs the generator **after** the man3 bindings and **before** Sphinx, mirroring `SENTINEL_OMPI_MAN3_BINDING`.
+- [x] Ensure VPATH builds write generated LLM artifacts to the build-tree staging directory, not the source tree (generator `--builddir`; outdir defaults to `$(builddir)/llms-build`).
+- [x] Add curated source artifacts (interface guide, examples, and the `*.schema.json` files) and the generator script (`generate-llm-docs.py`, `ompi_docs_common.py`) to `EXTRA_DIST`.
+- [x] Add `llms-build/` build output to `.gitignore` (alongside `html`, `man`, `man-openmpi/man3/bindings`) and to the `clean-local`/`maintainer-clean-local` rules.
+- [x] Ensure developer-tree builds regenerate LLM artifacts when source RST, binding metadata, generator code, or curated source artifacts change (sentinel prerequisites).
+- [x] Ensure developer-tree builds avoid regenerating LLM artifacts when output is already current (write-only-when-changed + sentinel mtime).
+- [x] Confirm rendered LLM artifacts are included in tarballs via the existing `html-local` copy (verified: `docs/html/llms/` populated after `make html-local`).
+- [~] Run `make dist` and validate that the generated LLM artifacts plus the curated sources are present inside the distribution tarball under the docs `html/` tree. *(Validated via the docs `make distdir`: it packages `html/llms.txt`, 532 `.md` artifacts, `llms-src/` sources, and the generator scripts. The full-tree `make dist` cannot complete in this `--disable-mpi-fortran` tree due to an unrelated missing Fortran generated header — `ompi/mpi/fortran/use-mpi-ignore-tkr`, not docs.)*
+- [x] Confirm release-tarball builds preserve/install/package pre-rendered LLM artifacts when Sphinx is unavailable, via the existing HTML install path (the artifacts ride inside `html/`, which the no-Sphinx path installs from the pre-rendered tree).
+- [~] Ensure missing pre-rendered LLM artifacts in a Git clone fail with a clear message when required tooling is unavailable. *(Inherited from the existing HTML/man no-Sphinx behavior; not separately exercised.)*
+- [x] Confirm LLM artifacts install under `$(docdir)` via the existing `install-data-hook` (no new install rule — it copies the entire `html` tree, which now contains `llms/`).
+- [x] Confirm `uninstall-hook` already removes installed LLM artifacts (no new uninstall rule — it removes `$(docdir)` recursively).
+- [x] Add `make distcheck`-safe handling for generated LLM artifacts and copied build-tree artifacts (`clean-local`/`distclean-local`/`maintainer-clean-local` remove `llms-build` and the copied `html`/`man`).
+- [~] Run `make distcheck` end to end with the LLM artifacts present (`DISTCHECK_CONFIGURE_FLAGS`, `venv/bin` on `PATH`, `AM_MAKEFLAGS="-j32"`). *(Blocked in this tree: `make distcheck` first runs `make dist`, which fails on the unrelated `--disable-mpi-fortran` Fortran-subdir issue above. The documented command remains for a Fortran-enabled CI environment.)*
+
+      PATH="$PWD/venv/bin:$PATH" make distcheck \
+        DISTCHECK_CONFIGURE_FLAGS="--disable-mpi-fortran --enable-sphinx --with-hwloc=internal --with-pmix=internal --with-prrte=internal --with-libevent=internal PKG_CONFIG_PATH=/opt/homebrew/lib/pkgconfig:" \
+        AM_MAKEFLAGS="-j32"
+- [x] Publish a versioned `llms.txt` for each documentation version (generated per build at the HTML version root).
+- [~] Publish a top-level `llms.txt` from the Read the Docs default version. *(RTD serves the default version's own self-describing `llms.txt` at `/`; there is no separate top-level index. A `/llms.txt` → versioned-path redirect is an available RTD-side option if different root behavior is ever needed.)*
+- [x] Add a concise human-facing link from `docs/index.rst` to the LLM-friendly documentation entry point.
+- [x] Add a short `docs/llm-friendly-docs.rst` landing page only if the front-page link needs more explanation than one sentence. *(Decision: the one-sentence `index.rst` entry suffices; no separate landing page added.)*
+- [x] Verify the local HTML build contains the generated `llms/` tree (`_build/html/llms/`, 525 per-symbol pages + corpora + manifest).
+- [x] Verify the local HTML build contains the versioned `llms.txt` (`_build/html/llms.txt`).
+- [~] Verify Read the Docs serves `/llms.txt` from the default version. *(Implementation wired for RTD: the generator runs in `.readthedocs-pre-create-environment.sh`, a `conf.py` `build-finished` hook copies the artifacts into the HTML output, and URLs use the RTD slug via `READTHEDOCS_CANONICAL_URL` (verified locally by simulating the RTD env → `…/en/main/…`). Live confirmation is still a post-merge RTD check — documented in Phase 8.)*
+- [~] Verify Read the Docs serves versioned LLM artifacts from versioned documentation URLs. *(Same RTD wiring as above; live confirmation is post-merge.)*
+
+## Phase 6: reproducible docs build (folded-in fix)
+
+- [x] Make `docs/conf.py` derive the copyright `year` from `SOURCE_DATE_EPOCH` when set, falling back to `datetime.now()` (verified: SDE=1700000000 -> 2023; unset -> current year).
+- [x] Verify the Sphinx "Last updated on:" HTML footer is reproducible under `SOURCE_DATE_EPOCH` (it is, via `format_date` in `sphinx/builders/html`).
+- [x] Check the nroff man-page `.TH` date for the same `SOURCE_DATE_EPOCH` reproducibility property and fix if needed (no fix needed: `sphinx/writers/manpage.py` sets the date via `format_date`, which honors `SOURCE_DATE_EPOCH`).
+- [~] Confirm the full docs build (HTML, man, LLM artifacts) is reproducible under a single `SOURCE_DATE_EPOCH` setting. *(Verified component-wise: copyright year, HTML footer, man `.TH` date, and the LLM artifacts all derive from `SOURCE_DATE_EPOCH`; the full two-build no-diff confirmation is the Phase 7 determinism check.)*
+
+## Phase 7: validation and CI
+
+All of the following are implemented in `docs/validate-llm-docs.py` and run via
+`make check` (a `check-local` target), which also performs the determinism
+rerun. `jsonschema` is added to `docs/requirements.txt`; the validator degrades
+gracefully (non-schema checks still run) if it is unavailable.
+
+- [x] Validate every JSONL record against the published `openmpi-mpi-api.schema.json` (covers JSONL syntax, required fields, and allowed enum values such as `project`, `kind`, `category`, and `languages`).
+- [x] Validate `openmpi-docs-manifest.json` against the published `openmpi-docs-manifest.schema.json`.
+- [x] Validate the cross-field invariant (beyond JSON Schema) that each record's `languages` equals the distinct set of its `bindings[].language`.
+- [x] Add validation that every JSONL record has at least one URL back to the human documentation.
+- [x] Add validation that the `docset` object contains no build-identity fields.
+- [x] Add validation that manifest hashes match generated artifact content.
+- [x] Add validation that manifest byte sizes match generated artifact content.
+- [x] Add validation that manifest entries cover every generated and curated artifact except the manifest itself.
+- [x] Add validation that the versioned `llms.txt` header carries no generation timestamp (so it stays semantic and listable in the manifest).
+- [x] Add validation that every artifact listed in `llms.txt` exists (the linked corpora/catalog/manifest/guide/examples are all manifest-covered and existence-checked).
+- [x] Add validation that Markdown files contain no unresolved `.. include::` directives.
+- [x] Add validation that Markdown files contain no unresolved Sphinx roles such as `:ref:`.
+- [x] Add validation that generated Markdown contains no accidental Sphinx-only substitution syntax.
+- [x] Add a determinism check: rerun the generator at a pinned `SOURCE_DATE_EPOCH`, commit, and `--url-base`, and assert no file diffs (including the manifest).
+- [x] Add a check that the sample JSONL records validate against the published JSON Schema.
+- [x] Add a check that the sample records match the generator's output for those procedures (the samples are generator-derived, so they must be regenerated when the generator changes).
+- [x] Compile curated/reused examples with wrapper compilers where practical (verified in Phase 4 with `mpicc -Wall`; the canonical `examples/` programs compile via `examples/Makefile`).
+- [~] Run small example smoke tests where practical and reliable in CI. *(Examples are compile-checked; runtime smoke tests are left to the existing `examples/` CI.)*
+- [~] Add Python compatibility checks for the new generator code against the 3.6 floor. *(All new Python uses 3.6-safe constructs — `str.format`, stdlib APIs available in 3.6; no automated 3.6-interpreter CI gate added.)*
+- [x] Add docs-build coverage for the Sphinx-enabled path (exercised by `make`/`make check` here and by Read the Docs with `fail_on_warning`).
+- [~] Add docs-build coverage, or a documented manual test, for the no-Sphinx pre-rendered tarball path. *(Documented; relies on the existing pre-rendered-tarball install path that the LLM artifacts ride.)*
+
+## Phase 8: release and documentation process
+
+Policy decisions for this phase (see spec "Release and maintenance process"):
+schema is additive within a version with a one-release deprecation window;
+version bumps only on breaking changes, owned by docs maintainers; schema
+bumps and notable field changes get a changelog entry while routine regen
+does not; artifacts get a one-time feature release note; release-time
+regeneration relies on the RM's existing `SOURCE_DATE_EPOCH` practice;
+publication is verified by a documented manual spot-check.
+
+All process documentation lives in the new
+`docs/developers/llm-friendly-docs.rst` page (linked from the developer-docs
+index), with the contributor sync expectation also in `AGENTS.md`.
+
+- [x] Document the schema compatibility policy: additive-only within a `schema_version`; a field may be deprecated (still emitted) for one release series before removal under a bump; no removal/rename/repurpose without a bump.
+- [x] Document that `schema_version`/`artifact_schema_version` bump only on a breaking change, owned by docs maintainers.
+- [x] Document that schema bumps and notable field changes get a `docs/release-notes/changelog/vMAJOR.MINOR.x.rst` entry, and that routine regeneration does not.
+- [x] Add the one-time feature release note when the artifacts first ship (`docs/release-notes/changelog/v6.1.x.rst`, added to the changelog index).
+- [x] Document the curated-doc sync expectation in **both** the developer docs and `AGENTS.md`: a PR changing public MPI docs should update affected curated LLM docs when relevant.
+- [~] Add a lightweight CI drift hint (not a hard gate) for likely curated-doc gaps. *(The sync expectation is documented in the developer docs and AGENTS.md. Not implemented: the validator checks that the manifest inventories every on-disk artifact, but does **not** check procedure-to-record or curated-symbol coverage, so coverage gaps are currently silent. An automated drift hint is left as a follow-up — curated-doc staleness cannot be detected reliably.)*
+- [x] Document that release-time regeneration relies on the RM's existing `SOURCE_DATE_EPOCH` reproducible-build practice; no separate regeneration step (in the developer LLM-docs page).
+- [x] Document the manual post-merge publication spot-check: fetch `/llms.txt` and one versioned artifact (e.g., the manifest) and confirm they resolve and parse.
+
+## Phase 9: follow-on work
+
+- [x] Generate a Markdown corpus for the section-1 command man pages (`mpirun`, `ompi_info`, the wrapper compilers, ...) under `llms/man-openmpi/man1/`, indexed in `llms.txt`. *(Markdown only — commands are not MPI APIs, so no JSONL catalog records. Reuses the existing RST→Markdown converter; stays in sync because it regenerates from the RST on every build.)*
+- [x] Use relative links for local (git) builds and absolute slug-correct links for Read the Docs builds. *(A local build targets a local LLM reading the files off disk, so every link — `llms.txt`, JSONL record `urls`, manifest `url`s, per-symbol/man1 Canonical-HTML headers — is relative to its own file; an RTD build uses `…/en/<slug>/…`. Implemented via the `LinkMaker` class.)*
+- [x] Make `llms.txt` self-describing for an LLM audience. *(An "about this file" section names the build — for a `main` RTD build, both the `main` slug and the `vA.B.x` series — documents the `…/en/VERSION_SLUG/` scheme for finding other versions' LLM docs, and points to the legacy README/FAQ/doc pages for pre-v5.0.0.)*
+- [~] Extend the same artifact model to OpenSHMEM public APIs. *(Deferred until someone asks for it, per the spec; not implemented.)*
+- [~] Add OpenSHMEM-specific schema examples before generating the OpenSHMEM catalog. *(Deferred with the OpenSHMEM work above.)*
+
+Considered and dropped: an `llms-full.txt` full-payload entry point, compressed
+downloadable bundles, and stable redirects for renamed artifacts. JSON Schema
+files were promoted into current scope (see Phases 1, 3, 5, and 7).
diff --git a/specs/ompio-mpi-info-support/spec.md b/specs/ompio-mpi-info-support/spec.md
new file mode 100644
index 00000000000..552865f4c4d
--- /dev/null
+++ b/specs/ompio-mpi-info-support/spec.md
@@ -0,0 +1,269 @@
+<!--
+  Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+
+  $COPYRIGHT$
+
+  Additional copyrights may follow
+
+  $HEADER$
+-->
+
+# OMPIO MPI_Info Hint Plan
+
+## Goal
+
+Make OMPIO comply with the MPI-5.0 `MPI_File_get_info` and
+`MPI_File_set_info` requirements by using Open MPI's existing
+`opal_infosubscriber_t` infrastructure.
+
+This work addresses Open MPI issue #13367, "`MPI_File_get_info`
+fails to return hints as required by MPI standard":
+https://github.com/open-mpi/ompi/issues/13367
+
+The implementation should:
+
+- Return all supported MPI-IO hints with default values.
+- Return user-supplied hints that OMPIO and its selected subcomponents
+  accepted.
+- Return additional hints set by the implementation.
+- Avoid returning ignored or unknown user hints.
+- Preserve user-supplied alias spelling when an alias is accepted.
+- Support hints at `MPI_File_open`, `MPI_File_set_info`, and
+  `MPI_File_set_view` time as appropriate for each hint.
+- Avoid a parallel OMPIO-private hint cache.
+
+## MPI-5.0 Requirements
+
+The governing text is the MPI-5.0 standard, section 15.2.8 ("File
+Info"), which defines `MPI_FILE_SET_INFO` and `MPI_FILE_GET_INFO`;
+section 15.2.8.1 ("Reserved File Hints") lists the reserved hint keys.
+
+Per section 15.2.8, `MPI_File_get_info` returns a newly created info
+object containing the current setting of all hints associated with the
+file. The standard requires the returned object to include:
+
+- Hints supported by the implementation that have specified default
+  values.
+- User-supplied hints that were not ignored.
+- Additional hints set by the implementation.
+
+The returned info object is caller-owned and must be freed by the
+caller with `MPI_Info_free`.
+
+Section 15.2.8 also requires `MPI_File_set_info` to update file hints
+without disturbing previous/default values for hints not present in
+the new info object. If a supplied hint is ignored, the previous value
+or default remains in effect.
+
+## Existing Infrastructure
+
+Use the existing `opal_infosubscriber_t` mechanism:
+
+- `opal_infosubscribe_subscribe()` registers supported keys, default
+  values, and callbacks.
+- `opal_infosubscribe_change_info()` applies a user info object through
+  registered callbacks.
+- `opal_info_dup_public()` produces a public copy suitable for
+  `MPI_File_get_info`.
+- `opal_info_set()` / `opal_info_set_cstring()` store accepted public
+  hints.
+
+`ompi_file_t::super.s_info` should be the authoritative current hint
+object. `ompio_file_t::f_info` should remain a borrowed pointer to that
+same object.
+
+Do not create a second OMPIO-owned list of hints.
+
+## OMPIO Helper Layer
+
+Add thin OMPIO-local helpers, likely under `ompi/mca/common/ompio/`,
+to keep call sites clean:
+
+- Subscribe a hint on the backing `ompi_file_t`.
+- Apply a user info object for a specific phase.
+- Set public implementation hints.
+- Duplicate public current hints for `MPI_File_get_info`.
+
+These helpers should wrap the existing `opal_infosubscriber_t` and
+`opal_info_t` APIs. They should not implement a new shared info
+framework.
+
+## Hint Context
+
+Add a small OMPIO hint phase/context to `ompio_file_t`, for example:
+
+- Open.
+- Set-info.
+- Set-view.
+
+Callbacks can use the phase to decide whether a hint is valid in the
+current operation. For example, filesystem layout hints may be accepted
+during file creation/open but ignored after the file already exists.
+
+## Component Ownership
+
+Each selected component should register its own hints and defaults.
+The OMPIO core should not hard-code hint names owned by `fs`, `fcoll`,
+`fbtl`, or `sharedfp` components.
+
+Initial hint owners to convert:
+
+- OMPIO common/core:
+  - `cb_buffer_size`
+  - `cb_nodes`
+  - `collective_buffering`
+
+- `fs/lustre`:
+  - `striping_unit`
+  - `striping_factor`
+  - `stripe_size` alias
+  - `stripe_width` alias
+
+- `sharedfp/individual`:
+  - `OMPIO_SHAREDFP_RELAXED_ORDERING`
+
+- `fs/gpfs`, when built:
+  - GPFS and SIOX keys currently consumed in
+    `ompi/mca/fs/gpfs/fs_gpfs_file_set_info.c`
+
+Other components can be added by registering their own hints through
+the same mechanism.
+
+## File Open Flow
+
+During file open:
+
+1. `ompi_file_open()` creates `fh->super.s_info`.
+2. OMPIO sets `ompio_fh->f_info = fh->super.s_info`.
+3. OMPIO selects the relevant subcomponents.
+4. Selected components subscribe their supported hints and defaults.
+5. OMPIO applies the original user info through
+   `opal_infosubscribe_change_info()`.
+6. OMPIO and subcomponents consume accepted/current hints from
+   `fh->super.s_info` / `ompio_fh->f_info`.
+
+Defaults must be registered before user hints are applied so that user
+hints can override defaults, and so that `MPI_File_get_info` can return
+supported defaulted hints even when the user passed `MPI_INFO_NULL`.
+
+## MPI_File_set_info Flow
+
+Add OMPIO module hooks:
+
+- `mca_io_ompio_file_set_info`
+- `mca_io_ompio_file_get_info`
+
+`mca_io_ompio_file_set_info` should:
+
+1. Lock the file handle.
+2. Set the OMPIO info phase to set-info.
+3. Apply the user info through `opal_infosubscribe_change_info()`.
+4. Let subscribed component callbacks accept, ignore, or transform
+   values.
+5. Let callbacks update component state for mutable hints.
+6. Leave omitted hints unchanged.
+7. Leave ignored hints at their previous/default values.
+8. Unlock and return.
+
+Hints that cannot be changed after open should be ignored in this
+phase by their owning component.
+
+## MPI_File_get_info Flow
+
+`mca_io_ompio_file_get_info` should:
+
+1. Allocate a new `ompi_info_t`.
+2. Duplicate public current hints from `fh->super.s_info` with
+   `opal_info_dup_public()`.
+3. Return the new object through `info_used`.
+
+OMPIO must not retain ownership of the returned object.
+
+## MPI_File_set_view Flow
+
+Route the `info` argument to `MPI_File_set_view` through the same
+subscription mechanism:
+
+1. Set the OMPIO info phase to set-view.
+2. Apply the view info through `opal_infosubscribe_change_info()`.
+3. Run view setup using accepted/current hints from `fh->super.s_info`.
+4. Preserve existing hints not mentioned by the set-view info object.
+
+This should replace ad hoc patterns where `mca_common_ompio_set_view`
+reads raw input info and manually copies accepted keys into
+`fh->f_info`.
+
+## Alias Handling
+
+If a user supplies an accepted alias, preserve the supplied spelling in
+`MPI_File_get_info`.
+
+For default values with no user-supplied spelling, use the canonical
+public key for that hint.
+
+## Documentation
+
+Update `docs/tuning-apps/mpi-io.rst` with a dedicated `MPI_Info hints`
+section.
+
+Document hints in tables grouped by owner/component. Each row should
+include:
+
+- Hint name.
+- Owner/component.
+- Whether it is accepted at `MPI_File_open`.
+- Whether it is accepted at `MPI_File_set_info`.
+- Whether it is accepted at `MPI_File_set_view`.
+- Default value, if any.
+- Corresponding MCA parameter, if any.
+- Notes, including alias behavior.
+
+Add short cross-references from the MPI file info man pages to the
+MPI-IO tuning page:
+
+- `docs/man-openmpi/man3/MPI_File_open.3.rst`
+- `docs/man-openmpi/man3/MPI_File_set_info.3.rst`
+- `docs/man-openmpi/man3/MPI_File_get_info.3.rst`
+
+## Test Plan
+
+Add a standalone MPI test under `test/simple`. Do not wire it into
+`make check`; Open MPI's `make check` does not run `mpirun`-launched
+tests.
+
+The test should be manually runnable, for example with:
+
+```sh
+mpirun -n 2 --mca io ompio ./ompio_file_info
+```
+
+Suggested coverage:
+
+- Open with `MPI_INFO_NULL`, call `MPI_File_get_info`, and verify
+  supported OMPIO defaulted hints are returned.
+- Open with a supported hint such as `cb_buffer_size`, and verify the
+  returned value.
+- Open with an unknown key, and verify it is not returned.
+- Verify accepted aliases preserve user spelling where the selected
+  component supports the alias.
+- Call `MPI_File_set_info` with a mutable supported hint, and verify
+  `MPI_File_get_info` reflects the update.
+- Call `MPI_File_set_info` with an unknown key, and verify previous or
+  default hints remain unchanged.
+- Call `MPI_File_set_view` with view-related accepted hints, and verify
+  `MPI_File_get_info` reflects accepted changes.
+
+Filesystem-specific cases should skip gracefully if the relevant
+component or filesystem is not active.
+
+## Risks
+
+The `opal_infosubscribe_subscribe()` callback returns `const char *`,
+which is convenient for static strings but awkward for dynamically
+formatted values. If a component needs to publish a dynamically
+computed implementation hint, it should set that value directly in
+`fh->super.s_info` through an OMPIO helper using `opal_info_set()`.
+
+The main ordering risk is applying user info before all relevant
+subcomponents have registered their subscriptions. OMPIO should ensure
+subscriptions are installed before reapplying open-time user info.
diff --git a/specs/ompio-mpi-info-support/tasks.md b/specs/ompio-mpi-info-support/tasks.md
new file mode 100644
index 00000000000..9321241b480
--- /dev/null
+++ b/specs/ompio-mpi-info-support/tasks.md
@@ -0,0 +1,282 @@
+<!--
+  Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+
+  $COPYRIGHT$
+
+  Additional copyrights may follow
+
+  $HEADER$
+-->
+
+# OMPIO MPI_Info Support Tasks
+
+This implementation is intentionally split into five waves. Each wave
+should leave the tree buildable, runnable, and reviewable before the
+next wave starts.
+
+When asked to "implement phase N", complete all tasks in that phase,
+run the listed verification for that phase, and stop before starting
+the next phase.
+
+## Phase 1: Core Infrastructure
+
+Goal: establish the OMPIO info plumbing with one simple OMPIO-owned
+hint so the model can be reviewed independently.
+
+Implementation tasks:
+
+- [x] Audit current OMPIO-related info calls and record the initial
+  hint inventory in the implementation notes or commit message:
+  - `ompi/mca/common/ompio/`
+  - `ompi/mca/io/ompio/`
+  - `ompi/mca/fs/`
+  - `ompi/mca/fcoll/`
+  - `ompi/mca/fbtl/`
+  - `ompi/mca/sharedfp/`
+- [x] Add OMPIO-local helper declarations and implementation under the
+  appropriate `ompi/mca/common/ompio/` files.
+- [x] Add helper support for:
+  - subscribing a hint on the backing `ompi_file_t`,
+  - applying a user info object through `opal_infosubscribe_change_info()`,
+  - setting public implementation hints,
+  - duplicating public current hints for `MPI_File_get_info`.
+- [x] Add an OMPIO info phase enum for open, set-info, and set-view.
+- [x] Add the current info phase to `ompio_file_t`.
+- [x] Ensure `ompio_file_t::f_info` is a borrowed pointer to
+  `ompi_file_t::super.s_info`.
+- [x] Add `mca_io_ompio_file_set_info()`.
+- [x] Add `mca_io_ompio_file_get_info()`.
+- [x] Wire both functions into `mca_io_ompio_module`.
+- [x] Register exactly one simple OMPIO-owned hint, preferably
+  `cb_buffer_size`, including its default.
+- [x] Reapply open-time user info after the Phase 1 subscription is
+  installed.
+- [x] Make `MPI_File_get_info` return public current hints from
+  `fh->super.s_info`.
+
+Behavior at the end of Phase 1:
+
+- OMPIO has its own get-info and set-info hooks.
+- `MPI_File_get_info` on an OMPIO file can return at least the one
+  registered defaulted hint.
+- Unknown user hints are not returned.
+- Existing OMPIO behavior for other hints is not intentionally changed.
+
+Verification:
+
+- [x] Build the touched OMPIO/common OMPIO sources.
+- [x] Verify the touched OMPIO files are compiled in the local
+  configuration.
+- [x] Manually run a tiny MPI-IO smoke test with `--mca io ompio`.
+- [x] Verify `MPI_File_get_info` returns the Phase 1 defaulted hint
+  after opening with `MPI_INFO_NULL`.
+- [x] Verify an unknown open-time hint is not returned.
+- [x] Review memory ownership:
+  - `fh->super.s_info` remains owned by `ompi_file_t`,
+  - `ompio_file_t::f_info` is borrowed,
+  - returned `MPI_Info` objects are caller-owned.
+
+## Phase 2: OMPIO Core Hints and Manual Test
+
+Goal: convert OMPIO common/core hints to the new mechanism and add a
+manual `test/simple` regression test for generic OMPIO behavior.
+
+Implementation tasks:
+
+- [x] Register `cb_buffer_size` if not completed in Phase 1.
+- [x] Register `cb_nodes`.
+- [x] Register `collective_buffering`.
+- [x] Move OMPIO common/core hint parsing to callbacks or helper-backed
+  accessors.
+- [x] Preserve existing MCA-parameter override behavior.
+- [x] Preserve current runtime behavior for:
+  - aggregator selection,
+  - collective buffering,
+  - collective I/O buffer sizing.
+- [x] Ensure omitted hints survive `MPI_File_set_info`.
+- [x] Ensure ignored/unknown hints do not become public.
+- [x] Add a standalone test under `test/simple`.
+- [x] Make the test build consistently with existing `test/simple`
+  conventions.
+- [x] Cover these generic OMPIO cases in the test:
+  - open with `MPI_INFO_NULL` and verify defaulted supported hints,
+  - open with `cb_buffer_size` and verify the returned value,
+  - open with an unknown key and verify it is not returned,
+  - call `MPI_File_set_info` with a supported mutable hint and verify
+    the update,
+  - call `MPI_File_set_info` with an unknown key and verify previous or
+    default hints remain unchanged.
+- [x] Document manual invocation in the test source comment or nearby
+  test notes, for example:
+
+  ```sh
+  mpirun -n 2 --mca io ompio ./ompio_file_info
+  ```
+
+Behavior at the end of Phase 2:
+
+- OMPIO common/core hints are handled through the existing
+  `opal_infosubscriber_t` mechanism.
+- Generic `MPI_File_get_info` / `MPI_File_set_info` behavior is
+  covered by a manually runnable test.
+- The tree remains useful even without Lustre or GPFS.
+
+Verification:
+
+- [x] Build OMPIO and the new `test/simple` test.
+- [x] Run the new test with `mpirun -n 2 --mca io ompio`.
+- [x] Run the test with supported and unsupported hints.
+- [x] Verify no generated MPI binding files were hand-edited.
+- [x] Check for warnings in touched code.
+
+## Phase 3: MPI_File_set_view Integration
+
+Goal: route `MPI_File_set_view` info handling through the same
+subscription path while keeping the tree fully runnable.
+
+Implementation tasks:
+
+- [x] Update `mca_io_ompio_file_set_view()` to apply its `info`
+  argument through the OMPIO helper layer.
+- [x] Set phase to set-view while applying view info.
+- [x] Preserve existing hints not mentioned in the view info object.
+- [x] Remove ad hoc copying of accepted view hints into `fh->f_info`.
+- [x] Verify view setup reads accepted/current hints from
+  `ompio_fh->f_info`.
+- [x] Extend the `test/simple` test to cover set-view accepted hint
+  handling.
+- [x] Confirm `cb_nodes` and `collective_buffering` semantics are
+  unchanged for view setup.
+
+Behavior at the end of Phase 3:
+
+- Open, set-info, and set-view all use the same OMPIO info mechanism
+  for OMPIO common/core hints.
+- Existing view setup behavior is preserved.
+- The manual test covers set-view info behavior.
+
+Verification:
+
+- [x] Build touched OMPIO files.
+- [x] Run the manual `test/simple` test with `--mca io ompio`.
+- [x] Run at least one smoke MPI-IO program that sets a non-default
+  file view.
+- [x] Confirm omitted hints survive set-view.
+- [x] Confirm unknown set-view hints are not returned by get-info.
+
+## Phase 4: Component-Owned Hints
+
+Goal: extend the mechanism to selected subcomponents without hard-coding
+their hint names in the OMPIO framework.
+
+Implementation tasks:
+
+- [x] Add `sharedfp/individual` subscription for
+  `OMPIO_SHAREDFP_RELAXED_ORDERING`.
+- [x] Move existing direct `fh->f_info` parsing in
+  `sharedfp/individual` to callback/helper logic.
+- [x] Preserve current sharedfp component priority/selection behavior.
+- [~] Add `fs/lustre` subscriptions for:
+  - `striping_unit`
+  - `striping_factor`
+  - `stripe_size`
+  - `stripe_width`
+- [~] Preserve accepted Lustre alias spelling in returned info.
+- [~] Treat Lustre layout hints as open/create-time hints unless the
+  component can safely apply them later.
+- [~] Add `fs/gpfs` subscriptions for supported GPFS/SIOX hints when
+  GPFS support is built.
+- [x] Keep filesystem-specific hint names inside their owning
+  components.
+- [~] Define how each alias stores its canonical relationship.
+- [~] Use canonical public spelling only when returning defaults with no
+  user-supplied spelling.
+- [x] Extend the manual test for alias spelling and component-owned
+  hints where the relevant component is available.
+- [x] Make filesystem-specific test sections skip gracefully when the
+  relevant component/filesystem is unavailable.
+
+Behavior at the end of Phase 4:
+
+- OMPIO common/core, `sharedfp/individual`, `fs/lustre`, and `fs/gpfs`
+  use component-owned hint registration.
+- OMPIO framework/common code does not hard-code hint names owned by
+  those components.
+- Filesystem-dependent behavior remains conditional and reviewable.
+
+Verification:
+
+- [x] Build touched OMPIO and sharedfp files.  The edited Lustre/GPFS
+  component sources could not be built in this local configuration
+  because the Lustre and GPFS development headers are unavailable.
+- [x] Run the manual `test/simple` test on a generic filesystem.
+- [ ] Run Lustre-specific checks only on Lustre or with a build where
+  the component can be selected safely.
+- [ ] Run GPFS-specific checks only when GPFS support is built and
+  available.
+- [x] Verify ignored component-specific hints are not returned.
+- [x] Verify accepted aliases preserve user spelling where locally
+  testable; Lustre alias runtime verification requires a Lustre-enabled
+  build and filesystem.
+- [x] Review for memory ownership and temporary `opal_cstring_t`
+  releases.
+
+## Phase 5: Documentation, Release Note, and Final Cleanup
+
+Goal: document the user-visible behavior and perform final consistency
+checks once the implementation behavior is settled.
+
+Implementation tasks:
+
+- [x] Add an `MPI_Info hints` section to
+  `docs/tuning-apps/mpi-io.rst`.
+- [x] Document hints in tables grouped by owner/component.
+- [x] Include accepted phases, defaults, MCA parameter mappings, and
+  notes.
+- [x] Document alias-preservation behavior.
+- [x] Add cross-references from:
+  - `docs/man-openmpi/man3/MPI_File_open.3.rst`
+  - `docs/man-openmpi/man3/MPI_File_set_view.3.rst`
+  - `docs/man-openmpi/man3/MPI_File_set_info.3.rst`
+  - `docs/man-openmpi/man3/MPI_File_get_info.3.rst`
+- [x] Add a shared include file so the same hint documentation appears
+  in the tuning guide and in the rendered MPI-IO man pages.
+- [x] Add a release-note/changelog entry under
+  `docs/release-notes/changelog/` if the behavior is deemed
+  user-visible.
+- [x] Add rationale comments to the non-obvious implementation paths,
+  especially where callbacks, cached info values, and staged updates
+  preserve MPI semantics.
+- [x] Review all touched code for Open MPI style:
+  - config header first,
+  - constants on the left in equality checks,
+  - braced blocks,
+  - 4-space indentation,
+  - no new global symbols without appropriate prefixes.
+- [x] Confirm no component-specific hint names are hard-coded in OMPIO
+  framework/common code unless OMPIO common/core owns them.
+- [x] Confirm generated MPI binding files were not hand-edited.
+- [x] Confirm no new memory ownership ambiguity:
+  - `fh->super.s_info` remains owned by `ompi_file_t`,
+  - `ompio_file_t::f_info` is borrowed,
+  - returned `MPI_Info` objects are caller-owned,
+  - temporary `opal_cstring_t` values are released.
+
+Behavior at the end of Phase 5:
+
+- The implementation is documented for users.
+- Manual test coverage exists for the implemented behavior.
+- The work is ready for full review.
+
+Verification:
+
+- [~] Build the touched code that is included in this local
+  configuration.  The edited Lustre/GPFS component sources could not be
+  built locally because the corresponding development headers are not
+  installed, matching the Phase 4 verification caveat.
+- [x] Run the manual `test/simple` test with `--mca io ompio`.
+- [x] Run documentation build checks if Sphinx is enabled.
+- [x] If build-system files were not changed, avoid unnecessary
+  `autogen.pl`; if they were changed, regenerate according to
+  `AGENTS.md`.
+- [x] Prepare a concise final test/verification summary for reviewers.
diff --git a/test/Makefile.am b/test/Makefile.am
index b3fd5f2f32c..730ab5ded4e 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -14,6 +14,7 @@
 # Copyright (c) 2015-2016 Research Organization for Information Science
 #                         and Technology (RIST). All rights reserved.
 # Copyright (c) 2017      IBM Corporation. All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -23,7 +24,4 @@
 
 # support needs to be first for dependencies
 SUBDIRS = support asm class threads datatype util mpool
-if PROJECT_OMPI
-SUBDIRS += monitoring spc
-endif
 DIST_SUBDIRS = event $(SUBDIRS)
diff --git a/test/class/Makefile.am b/test/class/Makefile.am
index 1e39017584b..ab42b2fe16d 100644
--- a/test/class/Makefile.am
+++ b/test/class/Makefile.am
@@ -14,6 +14,7 @@
 # Copyright (c) 2014      Research Organization for Information Science
 #                         and Technology (RIST). All rights reserved.
 # Copyright (c) 2016      IBM Corporation.  All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -23,83 +24,87 @@
 
 AM_CPPFLAGS="-I$(top_srcdir)/test/support"
 
-if PROJECT_OMPI
-  REQUIRES_OMPI = ompi_rb_tree
-endif
+# Make "make check" work in an uninstalled --enable-mca-dso build tree
+include $(top_srcdir)/Makefile.mca-dso-check
 
 check_PROGRAMS = \
-	$(REQUIRES_OMPI) opal_bitmap \
+	opal_bitmap \
 	opal_hash_table \
 	opal_proc_table \
+	opal_rb_tree \
 	opal_list \
 	opal_value_array \
 	opal_pointer_array \
 	opal_lifo \
 	opal_fifo \
-	opal_cstring
+	opal_cstring \
+	opal_interval_tree \
+	opal_ring_buffer \
+	opal_hotel \
+	opal_graph
 
 TESTS = $(check_PROGRAMS)
 
+# Common link line for the OPAL unit tests
+opal_test_ldadd = \
+	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
+	$(top_builddir)/test/support/libsupport.a
+
 opal_bitmap_SOURCES = opal_bitmap.c
-opal_bitmap_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-        $(top_builddir)/test/support/libsupport.a
-opal_bitmap_DEPENDENCIES = $(opal_bitmap_LDADD)
+opal_bitmap_LDADD = $(opal_test_ldadd)
+opal_bitmap_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_list_SOURCES = opal_list.c
-opal_list_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-        $(top_builddir)/test/support/libsupport.a
-opal_list_DEPENDENCIES = $(opal_list_LDADD)
+opal_list_LDADD = $(opal_test_ldadd)
+opal_list_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_hash_table_SOURCES = opal_hash_table.c
-opal_hash_table_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-        $(top_builddir)/test/support/libsupport.a
-opal_hash_table_DEPENDENCIES = $(opal_hash_table_LDADD)
+opal_hash_table_LDADD = $(opal_test_ldadd)
+opal_hash_table_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_proc_table_SOURCES = opal_proc_table.c
-opal_proc_table_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-        $(top_builddir)/test/support/libsupport.a
-opal_proc_table_DEPENDENCIES = $(opal_proc_table_LDADD)
+opal_proc_table_LDADD = $(opal_test_ldadd)
+opal_proc_table_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_pointer_array_SOURCES = opal_pointer_array.c
-opal_pointer_array_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-        $(top_builddir)/test/support/libsupport.a
-opal_pointer_array_DEPENDENCIES = $(opal_pointer_array_LDADD)
+opal_pointer_array_LDADD = $(opal_test_ldadd)
+opal_pointer_array_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_value_array_SOURCES = opal_value_array.c
-opal_value_array_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-        $(top_builddir)/test/support/libsupport.a
-opal_value_array_DEPENDENCIES = $(opal_value_array_LDADD)
-
-ompi_rb_tree_SOURCES = ompi_rb_tree.c
-ompi_rb_tree_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-	$(top_builddir)/test/support/libsupport.a
-ompi_rb_tree_DEPENDENCIES = $(ompi_rb_tree_LDADD)
+opal_value_array_LDADD = $(opal_test_ldadd)
+opal_value_array_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_rb_tree_SOURCES = opal_rb_tree.c
+opal_rb_tree_LDADD = $(opal_test_ldadd)
+opal_rb_tree_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_lifo_SOURCES = opal_lifo.c
-opal_lifo_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-	$(top_builddir)/test/support/libsupport.a
-opal_lifo_DEPENDENCIES = $(opal_lifo_LDADD)
+opal_lifo_LDADD = $(opal_test_ldadd)
+opal_lifo_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_fifo_SOURCES = opal_fifo.c
-opal_fifo_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-	$(top_builddir)/test/support/libsupport.a
-opal_fifo_DEPENDENCIES = $(opal_fifo_LDADD)
+opal_fifo_LDADD = $(opal_test_ldadd)
+opal_fifo_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_cstring_SOURCES = opal_cstring.c
-opal_cstring_LDADD = \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-	$(top_builddir)/test/support/libsupport.a
-opal_cstring_DEPENDENCIES = $(opal_cstring_LDADD)
+opal_cstring_LDADD = $(opal_test_ldadd)
+opal_cstring_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_interval_tree_SOURCES = opal_interval_tree.c
+opal_interval_tree_LDADD = $(opal_test_ldadd)
+opal_interval_tree_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_ring_buffer_SOURCES = opal_ring_buffer.c
+opal_ring_buffer_LDADD = $(opal_test_ldadd)
+opal_ring_buffer_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_hotel_SOURCES = opal_hotel.c
+opal_hotel_LDADD = $(opal_test_ldadd)
+opal_hotel_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_graph_SOURCES = opal_graph.c
+opal_graph_LDADD = $(opal_test_ldadd)
+opal_graph_DEPENDENCIES = $(opal_test_ldadd)
 
 clean-local:
 	rm -f opal_bitmap_test_out.txt opal_hash_table_test_out.txt opal_proc_table_test_out.txt
diff --git a/test/class/opal_bitmap.c b/test/class/opal_bitmap.c
index 4577dd6192b..7bccefd3960 100644
--- a/test/class/opal_bitmap.c
+++ b/test/class/opal_bitmap.c
@@ -1,419 +1,443 @@
 /*
- * Testcase for bitmap
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for opal_bitmap_t.  Exercises the full public API with
+ * self-checking assertions (via the support harness).  Note: the
+ * library is compiled with -DNDEBUG, so assert() is a no-op here --
+ * all verification must go through test_verify()/test_failure().
  */
 
 #include "opal_config.h"
 
-#include "support.h"
 #include <stdio.h>
 
+#include "support.h"
+
 #include "opal/class/opal_bitmap.h"
 #include "opal/constants.h"
 
-#define BSIZE            26
-#define OPAL_INVALID_BIT -1
-#define ERR_CODE         -2
-
-#define PRINT_VALID_ERR                                        \
-    fprintf(error_out, "================================ \n"); \
-    fprintf(error_out, "This is supposed to throw error  \n"); \
-    fprintf(error_out, "================================ \n")
-
-static void test_bitmap_set(opal_bitmap_t *bm);
-static void test_bitmap_clear(opal_bitmap_t *bm);
-static void test_bitmap_is_set(opal_bitmap_t *bm);
-static void test_bitmap_clear_all(opal_bitmap_t *bm);
-static void test_bitmap_set_all(opal_bitmap_t *bm);
-static void test_bitmap_find_and_set(opal_bitmap_t *bm);
-static void test_bitmap_num_set_bits(opal_bitmap_t *bm);
-
-static int set_bit(opal_bitmap_t *bm, int bit);
-static int clear_bit(opal_bitmap_t *bm, int bit);
-static int is_set_bit(opal_bitmap_t *bm, int bit);
-static int clear_all(opal_bitmap_t *bm);
-static int set_all(opal_bitmap_t *bm);
-static int find_and_set(opal_bitmap_t *bm, int bit);
-
-#define WANT_PRINT_BITMAP 0
-#if WANT_PRINT_BITMAP
-static void print_bitmap(opal_bitmap_t *bm);
-#endif
-
-static FILE *error_out = NULL;
+#define BSIZE 26
+
+/* Number of bits per underlying array element (mirrors the value used
+   internally by opal_bitmap.c). */
+#define BITS_PER_ELEMENT 64
+
+static void test_init_errors(void);
+static void test_set_and_is_set(void);
+static void test_clear(void);
+static void test_clear_and_set_all(void);
+static void test_find_and_set(void);
+static void test_num_bits(void);
+static void test_bitwise_ops(void);
+static void test_are_different(void);
+static void test_get_string(void);
+static void test_copy(void);
+static void test_max_size(void);
+static void test_size_accessor(void);
 
 int main(int argc, char *argv[])
 {
-    /* Local variables */
-    opal_bitmap_t bm;
-    int err;
-
-    /* Perform overall test initialization */
     test_init("opal_bitmap_t");
 
-#ifdef STANDALONE
-    error_out = stderr;
-#else
-    error_out = fopen("./opal_bitmap_test_out.txt", "w");
-    if (error_out == NULL)
-        error_out = stderr;
-#endif
+    test_init_errors();
+    test_set_and_is_set();
+    test_clear();
+    test_clear_and_set_all();
+    test_find_and_set();
+    test_num_bits();
+    test_bitwise_ops();
+    test_are_different();
+    test_get_string();
+    test_copy();
+    test_max_size();
+    test_size_accessor();
+
+    /* test_finalize() returns non-zero if any check failed, which
+       becomes this program's exit status for "make check". */
+    return test_finalize();
+}
 
-    /* Initialize bitmap  */
+static void test_init_errors(void)
+{
+    opal_bitmap_t bm;
     OBJ_CONSTRUCT(&bm, opal_bitmap_t);
-    PRINT_VALID_ERR;
-    err = opal_bitmap_init(NULL, 2);
-    if (err == OPAL_ERR_BAD_PARAM)
-        fprintf(error_out, "ERROR: Initialization of bitmap failed\n\n");
-
-    PRINT_VALID_ERR;
-    err = opal_bitmap_init(&bm, -1);
-    if (err == OPAL_ERR_BAD_PARAM)
-        fprintf(error_out, "ERROR: Initialization of bitmap failed \n\n");
-
-    err = opal_bitmap_init(&bm, BSIZE);
-    if (0 > err) {
-        fprintf(error_out, "Error in bitmap create -- aborting \n");
-        exit(-1);
-    }
 
-    fprintf(error_out, "\nTesting bitmap set... \n");
-    test_bitmap_set(&bm);
+    /* NULL bitmap is rejected */
+    test_verify("init(NULL) rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_init(NULL, 2));
+    /* non-positive sizes are rejected */
+    test_verify("init(size=-1) rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_init(&bm, -1));
+    test_verify("init(size=0) rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_init(&bm, 0));
+    /* valid size succeeds and rounds up to a whole element */
+    test_verify("init(BSIZE) ok", OPAL_SUCCESS == opal_bitmap_init(&bm, BSIZE));
+    test_verify("init rounds up to one element", BITS_PER_ELEMENT == opal_bitmap_size(&bm));
+    /* a freshly initialized bitmap is entirely clear */
+    test_verify("fresh bitmap is clear", opal_bitmap_is_clear(&bm));
+
+    OBJ_DESTRUCT(&bm);
+}
 
-    fprintf(error_out, "\nTesting bitmap clear ... \n");
-    test_bitmap_clear(&bm);
+static void test_set_and_is_set(void)
+{
+    opal_bitmap_t bm;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
+    opal_bitmap_init(&bm, BSIZE);
+
+    /* Set bits at element boundaries and beyond the initial size (which
+       must auto-expand the bitmap). */
+    int bits[] = {0, 1, 7, 8, 24, 31, 32, 44, 63, 64, 82};
+    int nbits = (int) (sizeof(bits) / sizeof(bits[0]));
+    for (int i = 0; i < nbits; ++i) {
+        test_verify("set_bit ok", OPAL_SUCCESS == opal_bitmap_set_bit(&bm, bits[i]));
+    }
+    for (int i = 0; i < nbits; ++i) {
+        test_verify("set bit reads back set", opal_bitmap_is_set_bit(&bm, bits[i]));
+    }
 
-    fprintf(error_out, "\nTesting bitmap is_set ... \n");
-    test_bitmap_is_set(&bm);
+    /* Setting bit 82 must have grown the bitmap past 82 bits. */
+    test_verify("set_bit auto-expanded", opal_bitmap_size(&bm) > 82);
 
-    fprintf(error_out, "\nTesting bitmap clear_all... \n");
-    test_bitmap_clear_all(&bm);
+    /* Bits we never set must read as unset. */
+    test_verify("unset bit 2 reads clear", !opal_bitmap_is_set_bit(&bm, 2));
+    test_verify("unset bit 30 reads clear", !opal_bitmap_is_set_bit(&bm, 30));
 
-    fprintf(error_out, "\nTesting bitmap set_all... \n");
-    test_bitmap_set_all(&bm);
+    /* Out-of-range / negative indices: set is rejected, is_set is false. */
+    test_verify("set_bit(-1) rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_set_bit(&bm, -1));
+    test_verify("is_set_bit(-1) false", !opal_bitmap_is_set_bit(&bm, -1));
+    test_verify("is_set_bit(huge) false", !opal_bitmap_is_set_bit(&bm, 1000000));
 
-    fprintf(error_out, "\nTesting bitmap find_and_set... \n");
-    test_bitmap_find_and_set(&bm);
+    OBJ_DESTRUCT(&bm);
+}
 
-    fprintf(error_out, "\nTesting bitmap num_set_bits... \n");
-    test_bitmap_num_set_bits(&bm);
+static void test_clear(void)
+{
+    opal_bitmap_t bm;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
+    opal_bitmap_init(&bm, BSIZE);
 
-    fprintf(error_out, "\n~~~~~~     Testing complete     ~~~~~~ \n\n");
+    opal_bitmap_set_bit(&bm, 5);
+    test_verify("bit 5 set", opal_bitmap_is_set_bit(&bm, 5));
+    test_verify("clear_bit ok", OPAL_SUCCESS == opal_bitmap_clear_bit(&bm, 5));
+    test_verify("bit 5 now clear", !opal_bitmap_is_set_bit(&bm, 5));
 
-    test_finalize();
-#ifndef STANDALONE
-    fclose(error_out);
-#endif
+    /* Negative and out-of-range bits are rejected (clear does not grow). */
+    test_verify("clear_bit(-1) rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_clear_bit(&bm, -1));
+    test_verify("clear_bit(out of range) rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_clear_bit(&bm, opal_bitmap_size(&bm)));
 
-    return 0;
+    OBJ_DESTRUCT(&bm);
 }
 
-void test_bitmap_set(opal_bitmap_t *bm)
+static void test_clear_and_set_all(void)
 {
-    int result = 0;
-
-    /* start of bitmap and boundaries */
-    set_bit(bm, 0);
-    set_bit(bm, 1);
-    set_bit(bm, 7);
-    set_bit(bm, 8);
-    /* middle of bitmap  */
-    set_bit(bm, 24);
-
-    /* end of bitmap initial size */
-    set_bit(bm, 31);
-    set_bit(bm, 32);
-
-    /* beyond bitmap -- this is valid */
-    set_bit(bm, 44);
-    set_bit(bm, 82);
-
-    /* invalid bit */
-    PRINT_VALID_ERR;
-    result = set_bit(bm, -1);
-    TEST_AND_REPORT(result, ERR_CODE, "opal_bitmap_set_bit");
-}
+    opal_bitmap_t bm;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
+    opal_bitmap_init(&bm, 128);
+    int size = opal_bitmap_size(&bm);
 
-void test_bitmap_clear(opal_bitmap_t *bm)
-{
-    int result = 0;
-
-    /* Valid set bits  */
-    clear_bit(bm, 29);
-    clear_bit(bm, 31);
-    clear_bit(bm, 33);
-    clear_bit(bm, 32);
-    clear_bit(bm, 0);
-
-    /* invalid bit */
-    PRINT_VALID_ERR;
-    result = clear_bit(bm, -1);
-    TEST_AND_REPORT(result, ERR_CODE, "opal_bitmap_clear_bit");
-    PRINT_VALID_ERR;
-    result = clear_bit(bm, 142);
-    TEST_AND_REPORT(result, ERR_CODE, "opal_bitmap_clear_bit");
-}
+    test_verify("set_all ok", OPAL_SUCCESS == opal_bitmap_set_all_bits(&bm));
+    test_verify("set_all -> not clear", !opal_bitmap_is_clear(&bm));
+    test_verify("set_all -> all bits set", size == opal_bitmap_num_set_bits(&bm, size));
+    test_verify("set_all -> no unset bits", 0 == opal_bitmap_num_unset_bits(&bm, size));
+    test_verify("set_all -> first bit set", opal_bitmap_is_set_bit(&bm, 0));
+    test_verify("set_all -> last bit set", opal_bitmap_is_set_bit(&bm, size - 1));
 
-void test_bitmap_is_set(opal_bitmap_t *bm)
-{
-    int result = 0;
-
-    /* First set some bits */
-    test_bitmap_set(bm);
-    is_set_bit(bm, 0);
-    is_set_bit(bm, 1);
-    is_set_bit(bm, 31);
-    is_set_bit(bm, 32);
-
-    result = is_set_bit(bm, 1122);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_is_set_bit");
-    is_set_bit(bm, -33);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_is_set_bit");
-    is_set_bit(bm, -1);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_is_set_bit");
-}
+    test_verify("clear_all ok", OPAL_SUCCESS == opal_bitmap_clear_all_bits(&bm));
+    test_verify("clear_all -> is_clear", opal_bitmap_is_clear(&bm));
+    test_verify("clear_all -> zero set bits", 0 == opal_bitmap_num_set_bits(&bm, size));
 
-void test_bitmap_find_and_set(opal_bitmap_t *bm)
-{
-    int bsize;
-    int result = 0;
+    /* NULL handling */
+    test_verify("set_all(NULL) rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_set_all_bits(NULL));
+    test_verify("clear_all(NULL) rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_clear_all_bits(NULL));
 
-    opal_bitmap_clear_all_bits(bm);
-    result = find_and_set(bm, 0);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
-    result = find_and_set(bm, 1);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
-    result = find_and_set(bm, 2);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
-    result = find_and_set(bm, 3);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
-
-    result = opal_bitmap_set_bit(bm, 5);
-    result = find_and_set(bm, 4);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
-
-    result = opal_bitmap_set_bit(bm, 6);
-    result = opal_bitmap_set_bit(bm, 7);
-
-    /* Setting beyond a char boundary */
-    result = find_and_set(bm, 8);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
-    opal_bitmap_set_bit(bm, 9);
-    result = find_and_set(bm, 10);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
-
-    /* Setting beyond the current size of bitmap  */
-    opal_bitmap_set_all_bits(bm);
-    bsize = opal_bitmap_size(bm);
-    result = find_and_set(bm, bsize);
-    TEST_AND_REPORT(result, 0, "opal_bitmap_find_and_set_first_unset_bit");
+    OBJ_DESTRUCT(&bm);
 }
 
-void test_bitmap_clear_all(opal_bitmap_t *bm)
+static void test_find_and_set(void)
 {
-    int result = clear_all(bm);
-    TEST_AND_REPORT(result, 0, " error in opal_bitmap_clear_all_bits");
+    opal_bitmap_t bm;
+    int pos;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
+    opal_bitmap_init(&bm, BSIZE);
+    opal_bitmap_clear_all_bits(&bm);
+
+    /* Repeatedly find-and-set the first unset bit: should yield 0,1,2,3 */
+    for (int expected = 0; expected < 4; ++expected) {
+        test_verify("find_and_set ok",
+                    OPAL_SUCCESS == opal_bitmap_find_and_set_first_unset_bit(&bm, &pos));
+        test_verify("find_and_set returns next free bit", pos == expected);
+    }
+
+    /* Pre-set bit 5; the next find should skip it and return 4, then 6. */
+    opal_bitmap_set_bit(&bm, 5);
+    opal_bitmap_find_and_set_first_unset_bit(&bm, &pos);
+    test_verify("find_and_set returns 4", 4 == pos);
+    opal_bitmap_find_and_set_first_unset_bit(&bm, &pos);
+    test_verify("find_and_set skips pre-set bit 5", 6 == pos);
+
+    /* When an element is completely full, find_and_set must expand and
+       return the first bit of the new element. */
+    opal_bitmap_set_all_bits(&bm);
+    int old_size = opal_bitmap_size(&bm);
+    test_verify("find_and_set on full bitmap ok",
+                OPAL_SUCCESS == opal_bitmap_find_and_set_first_unset_bit(&bm, &pos));
+    test_verify("find_and_set expands at boundary", pos == old_size);
+
+    test_verify("find_and_set(NULL) rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_find_and_set_first_unset_bit(NULL, &pos));
+
+    OBJ_DESTRUCT(&bm);
 }
 
-void test_bitmap_set_all(opal_bitmap_t *bm)
+static void test_num_bits(void)
 {
-    int result = set_all(bm);
-    TEST_AND_REPORT(result, 0, " error in opal_bitmap_set_ala_bitsl");
+    opal_bitmap_t bm;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
+    opal_bitmap_init(&bm, 256);
+
+    opal_bitmap_clear_all_bits(&bm);
+    test_verify("num_set on cleared == 0", 0 == opal_bitmap_num_set_bits(&bm, 64));
+
+    opal_bitmap_set_bit(&bm, 0);
+    opal_bitmap_set_bit(&bm, 1);
+    opal_bitmap_set_bit(&bm, 5);
+    opal_bitmap_set_bit(&bm, 63);
+    test_verify("num_set in first 64 == 4", 4 == opal_bitmap_num_set_bits(&bm, 64));
+    /* Partial element: only the first 10 bits -> bits 0,1,5 -> 3 */
+    test_verify("num_set partial element == 3", 3 == opal_bitmap_num_set_bits(&bm, 10));
+
+    /* Spread bits across multiple elements. */
+    opal_bitmap_set_bit(&bm, 64);
+    opal_bitmap_set_bit(&bm, 100);
+    opal_bitmap_set_bit(&bm, 200);
+    test_verify("num_set across 256 == 7", 7 == opal_bitmap_num_set_bits(&bm, 256));
+    test_verify("num_unset across 256 == 249", 249 == opal_bitmap_num_unset_bits(&bm, 256));
+
+    /* len is measured in bits, not elements: counting up to 200 excludes
+       bit 200 itself. */
+    test_verify("num_set up to 200 excludes bit 200", 6 == opal_bitmap_num_set_bits(&bm, 200));
+    test_verify("num_set up to 201 includes bit 200", 7 == opal_bitmap_num_set_bits(&bm, 201));
+
+    OBJ_DESTRUCT(&bm);
 }
 
-void test_bitmap_num_set_bits(opal_bitmap_t *bm)
+/* Initialize a bitmap to a given size with a caller-supplied 64-bit
+   pattern in its first element. */
+static void fill_pattern(opal_bitmap_t *bm, int size, uint64_t pattern)
 {
-    int result, expected;
-
-    /* Test 1: Clear all bits and count - should be 0 */
-    opal_bitmap_clear_all_bits(bm);
-    result = opal_bitmap_num_set_bits(bm, 64);
-    expected = 0;
-    TEST_AND_REPORT(result, expected, "opal_bitmap_num_set_bits: cleared bitmap");
-
-    /* Test 2: Set specific bits and count within first 64 bits */
-    opal_bitmap_set_bit(bm, 0);
-    opal_bitmap_set_bit(bm, 1);
-    opal_bitmap_set_bit(bm, 5);
-    opal_bitmap_set_bit(bm, 63);
-    result = opal_bitmap_num_set_bits(bm, 64);
-    expected = 4;
-    TEST_AND_REPORT(result, expected, "opal_bitmap_num_set_bits: 4 bits in first 64");
-
-    /* Test 3: Count partial element (len not a multiple of 64) */
-    /* Count only first 10 bits - should be 3 (bits 0, 1, 5) */
-    result = opal_bitmap_num_set_bits(bm, 10);
-    expected = 3;
-    TEST_AND_REPORT(result, expected, "opal_bitmap_num_set_bits: partial element (10 bits)");
-
-    /* Test 4: Count up to bit 63 - should include bit 63 */
-    result = opal_bitmap_num_set_bits(bm, 64);
-    expected = 4;
-    TEST_AND_REPORT(result, expected, "opal_bitmap_num_set_bits: up to bit 63");
-
-    /* Test 5: Set bits across multiple array elements */
-    opal_bitmap_set_bit(bm, 64);
-    opal_bitmap_set_bit(bm, 65);
-    opal_bitmap_set_bit(bm, 100);
-    opal_bitmap_set_bit(bm, 127);
-
-    /* Count across 128 bits (2 full elements) */
-    result = opal_bitmap_num_set_bits(bm, 128);
-    expected = 8; /* 4 from first element + 4 from second element */
-    TEST_AND_REPORT(result, expected, "opal_bitmap_num_set_bits: across 2 elements (128 bits)");
-
-    /* Test 6: Count partial second element (130 bits = 2 elements + 2 bits) */
-    result = opal_bitmap_num_set_bits(bm, 130);
-    expected = 8; /* Should still be 8, as bits 128-129 are not set */
-    TEST_AND_REPORT(result, expected,
-                    "opal_bitmap_num_set_bits: partial second element (130 bits)");
-
-    /* Test 7: Verify len is treated as bits, not array indices
-     * Set bit 200 and count up to 201 bits (not 201 array elements) */
+    opal_bitmap_init(bm, size);
     opal_bitmap_clear_all_bits(bm);
-    opal_bitmap_set_bit(bm, 200);
-    result = opal_bitmap_num_set_bits(bm, 201);
-    expected = 1;
-    TEST_AND_REPORT(result, expected,
-                    "opal_bitmap_num_set_bits: len treated as bits (201 bits)");
-
-    /* Test 8: Count up to 200 should not include bit 200 */
-    result = opal_bitmap_num_set_bits(bm, 200);
-    expected = 0;
-    TEST_AND_REPORT(result, expected,
-                    "opal_bitmap_num_set_bits: len boundary not included (200 bits)");
-
-    /* Test 9: Set all bits in first element and count partial */
-    opal_bitmap_clear_all_bits(bm);
-    for (int i = 0; i < 64; ++i) {
-        opal_bitmap_set_bit(bm, i);
+    for (int b = 0; b < 64; ++b) {
+        if (pattern & (1UL << b)) {
+            opal_bitmap_set_bit(bm, b);
+        }
     }
-    /* Count only first 50 bits - should be 50 */
-    result = opal_bitmap_num_set_bits(bm, 50);
-    expected = 50;
-    TEST_AND_REPORT(result, expected,
-                    "opal_bitmap_num_set_bits: partial full element (50 of 64 bits)");
-
-    /* Test 10: Edge case - count exactly one full element */
-    result = opal_bitmap_num_set_bits(bm, 64);
-    expected = 64;
-    TEST_AND_REPORT(result, expected,
-                    "opal_bitmap_num_set_bits: exactly one element (64 bits)");
-
-    /* Test 11: Test opal_bitmap_num_unset_bits consistency */
-    opal_bitmap_clear_all_bits(bm);
-    opal_bitmap_set_bit(bm, 5);
-    opal_bitmap_set_bit(bm, 10);
-    opal_bitmap_set_bit(bm, 15);
-    result = opal_bitmap_num_set_bits(bm, 64);
-    expected = 3;
-    TEST_AND_REPORT(result, expected, "opal_bitmap_num_set_bits: 3 set bits in 64");
-
-    result = opal_bitmap_num_unset_bits(bm, 64);
-    expected = 61; /* 64 - 3 = 61 */
-    TEST_AND_REPORT(result, expected, "opal_bitmap_num_unset_bits: 61 unset bits in 64");
 }
 
-int set_bit(opal_bitmap_t *bm, int bit)
+static void test_bitwise_ops(void)
 {
-    int err = opal_bitmap_set_bit(bm, bit);
-    if (err != 0 || !opal_bitmap_is_set_bit(bm, bit)) {
-        fprintf(error_out, "ERROR: set_bit for bit = %d\n\n", bit);
-        return ERR_CODE;
-    }
-    return 0;
+    opal_bitmap_t a, b;
+    OBJ_CONSTRUCT(&a, opal_bitmap_t);
+    OBJ_CONSTRUCT(&b, opal_bitmap_t);
+
+    /* AND */
+    fill_pattern(&a, 64, 0xF0F0UL);
+    fill_pattern(&b, 64, 0xFF00UL);
+    test_verify("and ok", OPAL_SUCCESS == opal_bitmap_bitwise_and_inplace(&a, &b));
+    test_verify("and result bit 12 set", opal_bitmap_is_set_bit(&a, 12)); /* 0xF000 */
+    test_verify("and result bit 4 clear", !opal_bitmap_is_set_bit(&a, 4));
+
+    /* OR */
+    fill_pattern(&a, 64, 0x0F0FUL);
+    fill_pattern(&b, 64, 0xF0F0UL);
+    test_verify("or ok", OPAL_SUCCESS == opal_bitmap_bitwise_or_inplace(&a, &b));
+    test_verify("or result == 0xFFFF (16 bits)", 16 == opal_bitmap_num_set_bits(&a, 16));
+
+    /* XOR */
+    fill_pattern(&a, 64, 0xFF00UL);
+    fill_pattern(&b, 64, 0x0FF0UL);
+    test_verify("xor ok", OPAL_SUCCESS == opal_bitmap_bitwise_xor_inplace(&a, &b));
+    test_verify("xor result bit 4 set", opal_bitmap_is_set_bit(&a, 4));   /* 0xF0F0 */
+    test_verify("xor result bit 8 clear", !opal_bitmap_is_set_bit(&a, 8));
+
+    /* Error paths: NULL operands and mismatched sizes. */
+    test_verify("and(NULL) rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_bitwise_and_inplace(&a, NULL));
+    test_verify("or(NULL) rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_bitwise_or_inplace(NULL, &b));
+    test_verify("xor(NULL) rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_bitwise_xor_inplace(&a, NULL));
+
+    opal_bitmap_t big;
+    OBJ_CONSTRUCT(&big, opal_bitmap_t);
+    opal_bitmap_init(&big, 256);
+    test_verify("and size mismatch rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_bitwise_and_inplace(&a, &big));
+    OBJ_DESTRUCT(&big);
+
+    OBJ_DESTRUCT(&a);
+    OBJ_DESTRUCT(&b);
 }
 
-int clear_bit(opal_bitmap_t *bm, int bit)
+static void test_are_different(void)
 {
-    int err = opal_bitmap_clear_bit(bm, bit);
-    if ((err != 0) || opal_bitmap_is_set_bit(bm, bit)) {
-        fprintf(error_out, "ERROR: clear_bit for bit = %d \n\n", bit);
-        return ERR_CODE;
-    }
-
-    return 0;
-}
+    opal_bitmap_t a, b;
+    OBJ_CONSTRUCT(&a, opal_bitmap_t);
+    OBJ_CONSTRUCT(&b, opal_bitmap_t);
 
-int is_set_bit(opal_bitmap_t *bm, int bit)
-{
-    bool result = opal_bitmap_is_set_bit(bm, bit);
+    fill_pattern(&a, 64, 0xABCDUL);
+    fill_pattern(&b, 64, 0xABCDUL);
+    test_verify("equal bitmaps not different", !opal_bitmap_are_different(&a, &b));
 
-    if (result) {
-        if (bit < 0) {
-            fprintf(error_out, "ERROR: is_set_bit for bit = %d \n\n", bit);
-            return ERR_CODE;
-        }
-        return 0;
-    }
+    opal_bitmap_set_bit(&b, 40);
+    test_verify("differing content is different", opal_bitmap_are_different(&a, &b));
 
-    if (!result) {
-        if (0 <= bit && bit <= bm->array_size && !opal_bitmap_is_set_bit(bm, bit)) {
-            fprintf(error_out, "ERROR: is_set_bit for bit = %d \n\n", bit);
-            return ERR_CODE;
-        }
-        return 0;
-    }
+    opal_bitmap_t big;
+    OBJ_CONSTRUCT(&big, opal_bitmap_t);
+    opal_bitmap_init(&big, 256);
+    test_verify("differing size is different", opal_bitmap_are_different(&a, &big));
+    OBJ_DESTRUCT(&big);
 
-    return 0;
+    OBJ_DESTRUCT(&a);
+    OBJ_DESTRUCT(&b);
 }
 
-int find_and_set(opal_bitmap_t *bm, int bit)
+static void test_get_string(void)
 {
-    int ret, pos;
-    /* bit here is the bit that should be found and set, in the top
-       level stub, this function will be called in sequence to test */
-
-    ret = opal_bitmap_find_and_set_first_unset_bit(bm, &pos);
-    if (ret != OPAL_SUCCESS)
-        return ret;
-
-    if (pos != bit) {
-        fprintf(error_out, "ERROR: find_and_set: expected to find_and_set %d\n\n", bit);
-        return ERR_CODE;
+    opal_bitmap_t bm;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
+    opal_bitmap_init(&bm, 64);
+    opal_bitmap_clear_all_bits(&bm);
+    opal_bitmap_set_bit(&bm, 0);
+    opal_bitmap_set_bit(&bm, 3);
+
+    char *s = opal_bitmap_get_string(&bm);
+    test_verify("get_string non-NULL", NULL != s);
+    if (NULL != s) {
+        test_verify("get_string length == size", (int) strlen(s) == opal_bitmap_size(&bm));
+        test_verify("get_string marks set bit 0", 'X' == s[0]);
+        test_verify("get_string marks unset bit 1", '_' == s[1]);
+        test_verify("get_string marks set bit 3", 'X' == s[3]);
+        free(s);
     }
+    test_verify("get_string(NULL) == NULL", NULL == opal_bitmap_get_string(NULL));
 
-    return 0;
+    OBJ_DESTRUCT(&bm);
 }
 
-int clear_all(opal_bitmap_t *bm)
+static void test_copy(void)
 {
-    int i;
-    if (OPAL_SUCCESS != opal_bitmap_clear_all_bits(bm)) {
-        return ERR_CODE;
-    }
-    for (i = 0; i < bm->array_size; ++i)
-        if (bm->bitmap[i] != 0) {
-            fprintf(error_out, "ERROR: clear_all for bitmap array entry %d\n\n", i);
-            return ERR_CODE;
-        }
-    return 0;
+    opal_bitmap_t src, dst;
+    OBJ_CONSTRUCT(&src, opal_bitmap_t);
+    OBJ_CONSTRUCT(&dst, opal_bitmap_t);
+
+    opal_bitmap_init(&src, 128);
+    opal_bitmap_clear_all_bits(&src);
+    opal_bitmap_set_bit(&src, 1);
+    opal_bitmap_set_bit(&src, 70);
+
+    /* Copy into a fresh (smaller/empty) destination -- exercises the
+       (re)allocation path. */
+    opal_bitmap_copy(&dst, &src);
+    test_verify("copy into empty dst matches src", !opal_bitmap_are_different(&dst, &src));
+    test_verify("copy preserved bit 1", opal_bitmap_is_set_bit(&dst, 1));
+    test_verify("copy preserved bit 70", opal_bitmap_is_set_bit(&dst, 70));
+
+    /* Copy again into an already-large-enough destination -- exercises the
+       no-realloc path. */
+    opal_bitmap_clear_all_bits(&src);
+    opal_bitmap_set_bit(&src, 5);
+    opal_bitmap_copy(&dst, &src);
+    test_verify("second copy matches src", !opal_bitmap_are_different(&dst, &src));
+    test_verify("second copy preserved bit 5", opal_bitmap_is_set_bit(&dst, 5));
+    test_verify("second copy cleared old bit 70", !opal_bitmap_is_set_bit(&dst, 70));
+
+    OBJ_DESTRUCT(&src);
+    OBJ_DESTRUCT(&dst);
 }
 
-int set_all(opal_bitmap_t *bm)
+static void test_max_size(void)
 {
-    int i;
-    if (OPAL_SUCCESS != opal_bitmap_set_all_bits(bm)) {
-        return ERR_CODE;
-    }
-    for (i = 0; i < bm->array_size; ++i)
-        if (bm->bitmap[i] != 0xffffffffffffffffUL) {
-            fprintf(error_out, "ERROR: set_all for bitmap array entry %d\n\n", i);
-            return ERR_CODE;
+    opal_bitmap_t bm;
+    opal_bitmap_t cap65;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
+
+    test_verify("set_max_size(NULL) rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_set_max_size(NULL, 64));
+
+    /* Cap the bitmap at 64 bits, then ask for more -> rejected. */
+    test_verify("set_max_size ok", OPAL_SUCCESS == opal_bitmap_set_max_size(&bm, 64));
+    test_verify("init beyond max rejected", OPAL_ERR_BAD_PARAM == opal_bitmap_init(&bm, 65));
+    test_verify("init within max ok", OPAL_SUCCESS == opal_bitmap_init(&bm, 64));
+
+    OBJ_DESTRUCT(&bm);
+
+    /*
+     * The cap is enforced in bits, not rounded up to a 64-bit word.  With
+     * a non-word-aligned cap of 65 bits, a request for 128 bits -- which
+     * rounds to the same 2-word allocation -- must still be rejected, and
+     * bit indices at or beyond the cap must be refused.
+     */
+    OBJ_CONSTRUCT(&cap65, opal_bitmap_t);
+    test_verify("set_max_size(65) ok", OPAL_SUCCESS == opal_bitmap_set_max_size(&cap65, 65));
+    test_verify("init(128) beyond 65-bit cap rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_init(&cap65, 128));
+    test_verify("init(66) beyond 65-bit cap rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_init(&cap65, 66));
+    test_verify("init(65) at cap ok", OPAL_SUCCESS == opal_bitmap_init(&cap65, 65));
+    test_verify("set_bit(64) within 65-bit cap ok",
+                OPAL_SUCCESS == opal_bitmap_set_bit(&cap65, 64));
+    test_verify("set_bit(65) at cap rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_set_bit(&cap65, 65));
+    test_verify("set_bit(100) beyond cap rejected",
+                OPAL_ERR_BAD_PARAM == opal_bitmap_set_bit(&cap65, 100));
+
+    /*
+     * find_and_set must honor the bit cap as well.  Fill every valid bit
+     * [0, 65); a further find_and_set then has no room and must refuse,
+     * rather than handing back an out-of-cap bit (e.g. bit 65) from the
+     * unused tail of the last allocated word.  (Regression: the within-word
+     * fast path used to set the bit without checking max_size.)
+     */
+    {
+        int pos = -1;
+        for (int b = 0; b < 65; b++) {
+            (void) opal_bitmap_set_bit(&cap65, b);
         }
-    return 0;
+        test_verify("find_and_set on a full 65-bit bitmap is refused",
+                    OPAL_SUCCESS != opal_bitmap_find_and_set_first_unset_bit(&cap65, &pos));
+        test_verify("find_and_set did not set an out-of-cap bit",
+                    !opal_bitmap_is_set_bit(&cap65, 65));
+    }
+
+    OBJ_DESTRUCT(&cap65);
 }
 
-#if WANT_PRINT_BITMAP
-void print_bitmap(opal_bitmap_t *bm)
+static void test_size_accessor(void)
 {
-    /* Accessing the fields within the structure, since its not an
-       opaque structure  */
+    opal_bitmap_t bm;
+    OBJ_CONSTRUCT(&bm, opal_bitmap_t);
 
-    int i;
-    for (i = 0; i < bm->array_size; ++i) {
-        fprintf(error_out, "---\n bitmap[%d] = %x \n---\n\n", i, (bm->bitmap[i] & 0xff));
-    }
-    fprintf(error_out, "========================= \n");
-    return;
+    test_verify("size(NULL) == 0", 0 == opal_bitmap_size(NULL));
+    opal_bitmap_init(&bm, 100);
+    /* 100 bits rounds up to 2 elements -> 128 bits. */
+    test_verify("size rounds up to element multiple", 128 == opal_bitmap_size(&bm));
+
+    OBJ_DESTRUCT(&bm);
 }
-#endif
diff --git a/test/class/opal_graph.c b/test/class/opal_graph.c
new file mode 100644
index 00000000000..44e7eecb96c
--- /dev/null
+++ b/test/class/opal_graph.c
@@ -0,0 +1,704 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for opal_graph_t and its full public API.
+ *
+ * Graph under test (directed, weighted):
+ *
+ *   A --(1)--> B --(2)--> C --(1)--> D --(3)--> E
+ *   A --(4)--> C          B --(5)--> D
+ *
+ * order (vertices) = 5, size (edges) = 6
+ *
+ * Hand-computed Dijkstra shortest paths FROM A:
+ *   dist(A,B) = 1  (direct)
+ *   dist(A,C) = 3  (A->B->C; direct A->C costs 4)
+ *   dist(A,D) = 4  (A->B->C->D)
+ *   dist(A,E) = 7  (A->B->C->D->E)
+ *   dist(E,A) = INFINITY  (E has no out-edges)
+ *   adjacent(A,C) = 4  (direct edge weight, != spf 3)
+ *
+ * NOTE: -DNDEBUG is set; assert() is a no-op. All verification uses
+ * test_verify().  Do NOT use assert().
+ */
+
+#include "opal_config.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "support.h"
+
+#include "opal/class/opal_graph.h"
+#include "opal/class/opal_pointer_array.h"
+#include "opal/class/opal_value_array.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+/* --------------------------------------------------------------------------
+ * Vertex data: each vertex carries a heap-allocated int label (A=0..E=4).
+ * The hooks let duplicate() / find_vertex() / print work.
+ * -------------------------------------------------------------------------- */
+
+static void my_copy_vertex_data(void **dst, void *src)
+{
+    if (NULL == *dst) {
+        *dst = malloc(sizeof(int));
+    }
+    *((int *) (*dst)) = *((int *) src);
+}
+
+static void my_free_vertex_data(void *data)
+{
+    free(data);
+}
+
+static void *my_alloc_vertex_data(void)
+{
+    return malloc(sizeof(int));
+}
+
+static int my_compare_vertex_data(void *data1, void *data2)
+{
+    int v1 = *((int *) data1);
+    int v2 = *((int *) data2);
+    if (v1 > v2) {
+        return 1;
+    }
+    if (v1 < v2) {
+        return -1;
+    }
+    return 0;
+}
+
+/* print_vertex MUST return malloc'd memory; opal_graph_print calls free(). */
+static char *my_print_vertex(void *data)
+{
+    char *buf = malloc(8);
+    if (NULL != buf) {
+        snprintf(buf, 8, "%c", 'A' + *((int *) data));
+    }
+    return buf;
+}
+
+/* Helper: allocate and populate a vertex with label idx (0=A..4=E). */
+static opal_graph_vertex_t *make_vertex(int idx)
+{
+    opal_graph_vertex_t *v = OBJ_NEW(opal_graph_vertex_t);
+    int *data = (int *) my_alloc_vertex_data();
+    *data = idx;
+    v->vertex_data = data;
+    v->alloc_vertex_data = my_alloc_vertex_data;
+    v->copy_vertex_data = my_copy_vertex_data;
+    v->free_vertex_data = my_free_vertex_data;
+    v->compare_vertex = my_compare_vertex_data;
+    v->print_vertex = my_print_vertex;
+    return v;
+}
+
+/* Helper: build an edge on the heap (weight w, start -> end). */
+static opal_graph_edge_t *make_edge(opal_graph_vertex_t *start,
+                                    opal_graph_vertex_t *end,
+                                    uint32_t w)
+{
+    opal_graph_edge_t *e = OBJ_NEW(opal_graph_edge_t);
+    e->start = start;
+    e->end = end;
+    e->weight = w;
+    return e;
+}
+
+/*
+ * Build the canonical test graph into *g.
+ * Vertices stored in vA..vE (all OBJ_NEW, owned by the graph).
+ * Edges: A->B:1, A->C:4, B->C:2, B->D:5, C->D:1, D->E:3
+ *        (all OBJ_NEW, owned by the graph after successful add_edge).
+ */
+static void build_graph(opal_graph_t **g,
+                        opal_graph_vertex_t **vA, opal_graph_vertex_t **vB,
+                        opal_graph_vertex_t **vC, opal_graph_vertex_t **vD,
+                        opal_graph_vertex_t **vE)
+{
+    *g = OBJ_NEW(opal_graph_t);
+    *vA = make_vertex(0);  /* A */
+    *vB = make_vertex(1);  /* B */
+    *vC = make_vertex(2);  /* C */
+    *vD = make_vertex(3);  /* D */
+    *vE = make_vertex(4);  /* E */
+
+    opal_graph_add_vertex(*g, *vA);
+    opal_graph_add_vertex(*g, *vB);
+    opal_graph_add_vertex(*g, *vC);
+    opal_graph_add_vertex(*g, *vD);
+    opal_graph_add_vertex(*g, *vE);
+
+    opal_graph_add_edge(*g, make_edge(*vA, *vB, 1));
+    opal_graph_add_edge(*g, make_edge(*vA, *vC, 4));
+    opal_graph_add_edge(*g, make_edge(*vB, *vC, 2));
+    opal_graph_add_edge(*g, make_edge(*vB, *vD, 5));
+    opal_graph_add_edge(*g, make_edge(*vC, *vD, 1));
+    opal_graph_add_edge(*g, make_edge(*vD, *vE, 3));
+}
+
+/*
+ * Destroy a graph and release the vertices that were OBJ_NEW'd.
+ * After OBJ_RELEASE(graph) the adjacency structure and edges are gone,
+ * but the vertices themselves are NOT freed by the graph — release them.
+ */
+static void destroy_graph(opal_graph_t *g,
+                           opal_graph_vertex_t *vA, opal_graph_vertex_t *vB,
+                           opal_graph_vertex_t *vC, opal_graph_vertex_t *vD,
+                           opal_graph_vertex_t *vE)
+{
+    OBJ_RELEASE(g);
+    OBJ_RELEASE(vA);
+    OBJ_RELEASE(vB);
+    OBJ_RELEASE(vC);
+    OBJ_RELEASE(vD);
+    OBJ_RELEASE(vE);
+}
+
+/* --------------------------------------------------------------------------
+ * Test sections
+ * -------------------------------------------------------------------------- */
+
+static void test_order_and_size(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    test_verify("order == 5", 5 == opal_graph_get_order(g));
+    test_verify("size == 6",  6 == opal_graph_get_size(g));
+
+    /* Adding the same vertex twice must be a no-op */
+    opal_graph_add_vertex(g, vA);
+    test_verify("add duplicate vertex -> order still 5", 5 == opal_graph_get_order(g));
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_add_edge_error(void)
+{
+    /* add_edge returns OPAL_ERROR when a vertex is not in the graph */
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    opal_graph_vertex_t *orphan;
+    opal_graph_edge_t *bad_edge;
+    int rc;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    orphan = make_vertex(9); /* not added to any graph */
+    bad_edge = make_edge(vA, orphan, 99);
+    rc = opal_graph_add_edge(g, bad_edge);
+    test_verify("add_edge with unknown end vertex returns OPAL_ERROR",
+                OPAL_ERROR == rc);
+    /* bad_edge was not adopted by the graph; release it ourselves. */
+    OBJ_RELEASE(bad_edge);
+    OBJ_RELEASE(orphan);
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_adjacent(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    uint32_t w;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    /* Direct edges */
+    w = opal_graph_adjacent(g, vA, vB);
+    test_verify("adjacent(A,B) == 1", 1 == w);
+
+    w = opal_graph_adjacent(g, vA, vC);
+    test_verify("adjacent(A,C) == 4 (direct edge, not shortest path)", 4 == w);
+
+    w = opal_graph_adjacent(g, vC, vD);
+    test_verify("adjacent(C,D) == 1", 1 == w);
+
+    w = opal_graph_adjacent(g, vD, vE);
+    test_verify("adjacent(D,E) == 3", 3 == w);
+
+    /* No direct edge from A to D */
+    w = opal_graph_adjacent(g, vA, vD);
+    test_verify("adjacent(A,D) == INFINITY (no direct edge)",
+                DISTANCE_INFINITY == w);
+
+    /* No out-edges from E */
+    w = opal_graph_adjacent(g, vE, vA);
+    test_verify("adjacent(E,A) == INFINITY", DISTANCE_INFINITY == w);
+
+    /* Self-loop: adjacent(v,v) == 0 per the source */
+    w = opal_graph_adjacent(g, vA, vA);
+    test_verify("adjacent(A,A) == 0", 0 == w);
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_find_vertex(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    opal_graph_vertex_t *found;
+    int key;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    key = 0; /* A */
+    found = opal_graph_find_vertex(g, &key);
+    test_verify("find_vertex A by data returns vA", vA == found);
+
+    key = 4; /* E */
+    found = opal_graph_find_vertex(g, &key);
+    test_verify("find_vertex E by data returns vE", vE == found);
+
+    key = 99; /* not in graph */
+    found = opal_graph_find_vertex(g, &key);
+    test_verify("find_vertex unknown returns NULL", NULL == found);
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_get_graph_vertices(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    opal_pointer_array_t *arr;
+    int n;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    arr = OBJ_NEW(opal_pointer_array_t);
+    opal_pointer_array_init(arr, 8, INT_MAX, 8);
+    n = opal_graph_get_graph_vertices(g, arr);
+    test_verify("get_graph_vertices returns order", 5 == n);
+
+    /* Every vertex pointer should appear exactly once somewhere in arr. */
+    {
+        int i;
+        int found_A = 0, found_E = 0;
+        for (i = 0; i < n; i++) {
+            void *p = opal_pointer_array_get_item(arr, i);
+            if (p == (void *) vA) {
+                found_A = 1;
+            }
+            if (p == (void *) vE) {
+                found_E = 1;
+            }
+        }
+        test_verify("get_graph_vertices contains vA", 1 == found_A);
+        test_verify("get_graph_vertices contains vE", 1 == found_E);
+    }
+    OBJ_RELEASE(arr);
+
+    /* Empty graph returns 0 */
+    {
+        opal_graph_t *empty = OBJ_NEW(opal_graph_t);
+        opal_pointer_array_t *arr2 = OBJ_NEW(opal_pointer_array_t);
+        opal_pointer_array_init(arr2, 4, INT_MAX, 4);
+        n = opal_graph_get_graph_vertices(empty, arr2);
+        test_verify("get_graph_vertices on empty graph == 0", 0 == n);
+        OBJ_RELEASE(arr2);
+        OBJ_RELEASE(empty);
+    }
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_get_adjacent_vertices(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    opal_value_array_t adj;
+    int n;
+    size_t i;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    OBJ_CONSTRUCT(&adj, opal_value_array_t);
+    opal_value_array_init(&adj, sizeof(vertex_distance_from_t));
+
+    /* A has out-edges to B(1) and C(4) */
+    n = opal_graph_get_adjacent_vertices(g, vA, &adj);
+    test_verify("get_adjacent_vertices(A) == 2", 2 == n);
+    {
+        int found_B = 0, found_C = 0;
+        for (i = 0; i < opal_value_array_get_size(&adj); i++) {
+            vertex_distance_from_t *vd = (vertex_distance_from_t *)
+                opal_value_array_get_item(&adj, i);
+            if (NULL == vd) {
+                continue;
+            }
+            if (vd->vertex == vB && 1 == vd->weight) {
+                found_B = 1;
+            }
+            if (vd->vertex == vC && 4 == vd->weight) {
+                found_C = 1;
+            }
+        }
+        test_verify("adjacent_vertices(A) contains B with weight 1", 1 == found_B);
+        test_verify("adjacent_vertices(A) contains C with weight 4", 1 == found_C);
+    }
+
+    /* E has no out-edges */
+    opal_value_array_set_size(&adj, 0);
+    n = opal_graph_get_adjacent_vertices(g, vE, &adj);
+    test_verify("get_adjacent_vertices(E) == 0 (no out-edges)", 0 == n);
+
+    OBJ_DESTRUCT(&adj);
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_dijkstra(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    opal_value_array_t dist;
+    uint32_t n;
+    size_t i;
+    int found_B = 0, found_C = 0, found_D = 0, found_E = 0;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    OBJ_CONSTRUCT(&dist, opal_value_array_t);
+    opal_value_array_init(&dist, sizeof(vertex_distance_from_t));
+    opal_value_array_reserve(&dist, 10);
+
+    /* Dijkstra from A: output has order-1 == 4 entries (source excluded). */
+    n = opal_graph_dijkstra(g, vA, &dist);
+    test_verify("dijkstra from A returns order-1 == 4 entries", 4 == n);
+
+    /*
+     * Hand-computed shortest distances from A:
+     *   B=1, C=3 (via A->B->C), D=4 (via A->B->C->D), E=7 (via A->B->C->D->E)
+     * Note: adjacent(A,C)=4 but shortest path is 3.
+     */
+    for (i = 0; i < opal_value_array_get_size(&dist); i++) {
+        vertex_distance_from_t *vd = (vertex_distance_from_t *)
+            opal_value_array_get_item(&dist, i);
+        if (NULL == vd) {
+            continue;
+        }
+        if (vd->vertex == vB) {
+            found_B = 1;
+            test_verify("dijkstra dist(A,B) == 1", 1 == vd->weight);
+        }
+        if (vd->vertex == vC) {
+            found_C = 1;
+            /* Shortest via B->C (1+2=3), not direct A->C (4). */
+            test_verify("dijkstra dist(A,C) == 3 (via B, not direct)", 3 == vd->weight);
+        }
+        if (vd->vertex == vD) {
+            found_D = 1;
+            test_verify("dijkstra dist(A,D) == 4", 4 == vd->weight);
+        }
+        if (vd->vertex == vE) {
+            found_E = 1;
+            test_verify("dijkstra dist(A,E) == 7", 7 == vd->weight);
+        }
+    }
+    test_verify("dijkstra output contained B", 1 == found_B);
+    test_verify("dijkstra output contained C", 1 == found_C);
+    test_verify("dijkstra output contained D", 1 == found_D);
+    test_verify("dijkstra output contained E", 1 == found_E);
+
+    OBJ_DESTRUCT(&dist);
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_spf(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    uint32_t d;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    d = opal_graph_spf(g, vA, vB);
+    test_verify("spf(A,B) == 1", 1 == d);
+
+    d = opal_graph_spf(g, vA, vC);
+    test_verify("spf(A,C) == 3 (NOT 4; shortest is via B)", 3 == d);
+
+    d = opal_graph_spf(g, vA, vD);
+    test_verify("spf(A,D) == 4", 4 == d);
+
+    d = opal_graph_spf(g, vA, vE);
+    test_verify("spf(A,E) == 7", 7 == d);
+
+    /* No path from E back to A */
+    d = opal_graph_spf(g, vE, vA);
+    test_verify("spf(E,A) == INFINITY (no out-edges from E)",
+                DISTANCE_INFINITY == d);
+
+    /*
+     * Note: opal_graph_spf(v, v) (the trivial self path) currently returns
+     * DISTANCE_INFINITY rather than 0, because opal_graph_dijkstra()
+     * excludes the source vertex (Q[0]) from its output array, so spf()
+     * never finds vertex2 == vertex1.  Whether that ought to be 0 is
+     * arguably a defect, but "fixing" it would change dijkstra()'s
+     * published output for every caller, so we only exercise the path here
+     * (for coverage) without asserting a specific self-distance value.
+     */
+    d = opal_graph_spf(g, vA, vA);
+    (void) d;
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_remove_edge(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    opal_graph_edge_t *e_extra;
+    uint32_t w;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    /* Add a second edge A->B with weight 10, then remove it. */
+    e_extra = make_edge(vA, vB, 10);
+    opal_graph_add_edge(g, e_extra);
+    test_verify("size after add extra edge == 7", 7 == opal_graph_get_size(g));
+
+    /* remove_edge un-lists the edge but does NOT free it. */
+    opal_graph_remove_edge(g, e_extra);
+    test_verify("size after remove_edge == 6", 6 == opal_graph_get_size(g));
+
+    /* The removed edge is no longer found via adjacent -- only the 1-weight
+       edge should remain, so adjacent(A,B) is back to 1. */
+    w = opal_graph_adjacent(g, vA, vB);
+    test_verify("adjacent(A,B) == 1 after removing weight-10 edge", 1 == w);
+
+    /* Must free the removed edge ourselves (per API comment). */
+    OBJ_RELEASE(e_extra);
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+static void test_remove_vertex(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    /*
+     * Remove C.  Edges removed: A->C(4), B->C(2), C->D(1) — three edges.
+     * remove_vertex() also frees vC via OBJ_RELEASE, so we must NOT
+     * release vC ourselves after this point.
+     */
+    opal_graph_remove_vertex(g, vC);
+    vC = NULL; /* freed inside remove_vertex */
+
+    test_verify("order after removing C == 4", 4 == opal_graph_get_order(g));
+
+    /*
+     * remove_vertex() frees the three edges touching C (A->C, B->C, C->D)
+     * and keeps the graph's edge count in sync, so get_size() drops from
+     * 6 to 3.
+     */
+    test_verify("size after removing C == 3", 3 == opal_graph_get_size(g));
+
+    /* Remaining edges: A->B:1, B->D:5, D->E:3 */
+    test_verify("adjacent(A,B) still 1 after removing C", 1 ==
+                opal_graph_adjacent(g, vA, vB));
+    test_verify("adjacent(B,D) still 5 after removing C", 5 ==
+                opal_graph_adjacent(g, vB, vD));
+    test_verify("adjacent(D,E) still 3 after removing C", 3 ==
+                opal_graph_adjacent(g, vD, vE));
+
+    /* A->C no longer valid (C is gone) -- release graph then remaining vertices. */
+    OBJ_RELEASE(g);
+    OBJ_RELEASE(vA);
+    OBJ_RELEASE(vB);
+    /* vC already freed */
+    OBJ_RELEASE(vD);
+    OBJ_RELEASE(vE);
+}
+
+static void test_duplicate(void)
+{
+    opal_graph_t *src, *dst;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+    opal_pointer_array_t *arr;
+    int n;
+
+    build_graph(&src, &vA, &vB, &vC, &vD, &vE);
+
+    opal_graph_duplicate(&dst, src);
+
+    test_verify("duplicate order matches source", opal_graph_get_order(src) ==
+                opal_graph_get_order(dst));
+    test_verify("duplicate size matches source", opal_graph_get_size(src) ==
+                opal_graph_get_size(dst));
+    test_verify("duplicate order == 5", 5 == opal_graph_get_order(dst));
+    test_verify("duplicate size == 6",  6 == opal_graph_get_size(dst));
+
+    /* Verify the duplicate's vertices are distinct objects from the source's. */
+    arr = OBJ_NEW(opal_pointer_array_t);
+    opal_pointer_array_init(arr, 8, INT_MAX, 8);
+    n = opal_graph_get_graph_vertices(dst, arr);
+    test_verify("duplicate get_graph_vertices == 5", 5 == n);
+    {
+        int i;
+        int distinct = 1;
+        for (i = 0; i < n; i++) {
+            void *p = opal_pointer_array_get_item(arr, i);
+            if (p == (void *) vA || p == (void *) vB ||
+                p == (void *) vC || p == (void *) vD ||
+                p == (void *) vE) {
+                distinct = 0;
+                break;
+            }
+        }
+        test_verify("duplicate vertices are new objects (not the originals)", 1 == distinct);
+    }
+    OBJ_RELEASE(arr);
+
+    /*
+     * Verify adjacency is preserved in the duplicate.
+     * We can't use the original vertex pointers against dst; use find_vertex
+     * (which relies on compare_vertex being set, which duplicate copies).
+     */
+    {
+        int key_a = 0, key_b = 1, key_c = 2;
+        opal_graph_vertex_t *da, *db, *dc;
+        uint32_t w;
+
+        da = opal_graph_find_vertex(dst, &key_a);
+        db = opal_graph_find_vertex(dst, &key_b);
+        dc = opal_graph_find_vertex(dst, &key_c);
+
+        test_verify("find_vertex A in duplicate non-NULL", NULL != da);
+        test_verify("find_vertex B in duplicate non-NULL", NULL != db);
+        test_verify("find_vertex C in duplicate non-NULL", NULL != dc);
+
+        if (NULL != da && NULL != db) {
+            w = opal_graph_adjacent(dst, da, db);
+            test_verify("duplicate adjacent(A,B) == 1", 1 == w);
+        }
+        if (NULL != da && NULL != dc) {
+            w = opal_graph_adjacent(dst, da, dc);
+            test_verify("duplicate adjacent(A,C) == 4", 4 == w);
+        }
+    }
+
+    /*
+     * Release the duplicate.  opal_graph_duplicate creates its own vertices
+     * via OBJ_NEW, adds them, and the duplicate graph owns them via the
+     * adjacency list.  However, the graph destructor does NOT free vertices.
+     * Collect them first, then release the graph, then release each vertex.
+     */
+    {
+        opal_pointer_array_t *dst_verts = OBJ_NEW(opal_pointer_array_t);
+        int i, cnt;
+        opal_pointer_array_init(dst_verts, 8, INT_MAX, 8);
+        cnt = opal_graph_get_graph_vertices(dst, dst_verts);
+        OBJ_RELEASE(dst);
+        for (i = 0; i < cnt; i++) {
+            opal_graph_vertex_t *v = (opal_graph_vertex_t *)
+                opal_pointer_array_get_item(dst_verts, i);
+            if (NULL != v) {
+                OBJ_RELEASE(v);
+            }
+        }
+        OBJ_RELEASE(dst_verts);
+    }
+
+    destroy_graph(src, vA, vB, vC, vD, vE);
+}
+
+static void test_print(void)
+{
+    opal_graph_t *g;
+    opal_graph_vertex_t *vA, *vB, *vC, *vD, *vE;
+
+    build_graph(&g, &vA, &vB, &vC, &vD, &vE);
+
+    /*
+     * opal_graph_print() calls opal_output() to print the graph to
+     * stream 0. There is no return value; we just verify it does not
+     * crash, which is covered by reaching this point.
+     */
+    opal_graph_print(g);
+    test_verify("opal_graph_print completes without crash", 1);
+
+    /* Also exercise with NULL print_vertex hooks (should print empty strings). */
+    {
+        opal_graph_t *g2 = OBJ_NEW(opal_graph_t);
+        opal_graph_vertex_t *v1 = OBJ_NEW(opal_graph_vertex_t);
+        opal_graph_vertex_t *v2 = OBJ_NEW(opal_graph_vertex_t);
+        opal_graph_edge_t *e = make_edge(v1, v2, 7);
+
+        /* No print_vertex hook; print_vertex == NULL on construct. */
+        opal_graph_add_vertex(g2, v1);
+        opal_graph_add_vertex(g2, v2);
+        opal_graph_add_edge(g2, e);
+
+        opal_graph_print(g2);
+        test_verify("opal_graph_print with NULL hooks completes", 1);
+
+        OBJ_RELEASE(g2);
+        OBJ_RELEASE(v1);
+        OBJ_RELEASE(v2);
+    }
+
+    destroy_graph(g, vA, vB, vC, vD, vE);
+}
+
+/* --------------------------------------------------------------------------
+ * main
+ * -------------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    int rc;
+
+    test_init("opal_graph_t");
+
+    rc = opal_init_util(&argc, &argv);
+    test_verify("opal_init_util succeeds", OPAL_SUCCESS == rc);
+    if (OPAL_SUCCESS != rc) {
+        return test_finalize();
+    }
+
+    test_order_and_size();
+    test_add_edge_error();
+    test_adjacent();
+    test_find_vertex();
+    test_get_graph_vertices();
+    test_get_adjacent_vertices();
+    test_dijkstra();
+    test_spf();
+    test_remove_edge();
+    test_remove_vertex();
+    test_duplicate();
+    test_print();
+
+    opal_finalize_util();
+
+    return test_finalize();
+}
diff --git a/test/class/opal_hash_table.c b/test/class/opal_hash_table.c
index 4ae405accc7..cabd6ce6d6a 100644
--- a/test/class/opal_hash_table.c
+++ b/test/class/opal_hash_table.c
@@ -14,6 +14,7 @@
  *                         All rights reserved.
  * Copyright (c) 2014-2015 Mellanox Technologies, Inc.
  *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -242,6 +243,212 @@ static void test_static(void)
     OBJ_DESTRUCT(&table);
 }
 
+/* Values used by uint64 and ptr key family tests.  These are mutable
+ * char arrays (rather than char * to string literals) so the build stays
+ * warning-free under -Wwrite-strings; the tests only use them as opaque
+ * pointers. */
+static char val_a[] = "alpha";
+static char val_b[] = "beta";
+static char val_c[] = "gamma";
+
+static void test_uint64_keys(void)
+{
+    opal_hash_table_t table;
+    uint64_t key;
+    void *value;
+    void *node;
+    int rc;
+    size_t count;
+
+    fprintf(error_out, "\nTesting uint64 key family...\n");
+
+    OBJ_CONSTRUCT(&table, opal_hash_table_t);
+    opal_hash_table_init(&table, 8);
+
+    /* basic set / get */
+    rc = opal_hash_table_set_value_uint64(&table, UINT64_C(0xDEADBEEF00000001), val_a);
+    test_verify("set uint64 key 1 succeeds", OPAL_SUCCESS == rc);
+
+    rc = opal_hash_table_set_value_uint64(&table, UINT64_C(0xDEADBEEF00000002), val_b);
+    test_verify("set uint64 key 2 succeeds", OPAL_SUCCESS == rc);
+
+    rc = opal_hash_table_set_value_uint64(&table, UINT64_C(0xDEADBEEF00000003), val_c);
+    test_verify("set uint64 key 3 succeeds", OPAL_SUCCESS == rc);
+
+    test_verify("get_size after 3 inserts", 3 == opal_hash_table_get_size(&table));
+
+    rc = opal_hash_table_get_value_uint64(&table, UINT64_C(0xDEADBEEF00000001), &value);
+    test_verify("get uint64 key 1 found", OPAL_SUCCESS == rc);
+    test_verify("get uint64 key 1 value correct", value == val_a);
+
+    rc = opal_hash_table_get_value_uint64(&table, UINT64_C(0xDEADBEEF00000002), &value);
+    test_verify("get uint64 key 2 found", OPAL_SUCCESS == rc);
+    test_verify("get uint64 key 2 value correct", value == val_b);
+
+    /* get non-existent key */
+    rc = opal_hash_table_get_value_uint64(&table, UINT64_C(0xFFFFFFFFFFFFFFFF), &value);
+    test_verify("get uint64 missing key returns not-found", OPAL_ERR_NOT_FOUND == rc);
+
+    /* overwrite existing key */
+    rc = opal_hash_table_set_value_uint64(&table, UINT64_C(0xDEADBEEF00000001), val_c);
+    test_verify("overwrite uint64 key 1 succeeds", OPAL_SUCCESS == rc);
+    rc = opal_hash_table_get_value_uint64(&table, UINT64_C(0xDEADBEEF00000001), &value);
+    test_verify("get uint64 key 1 after overwrite", OPAL_SUCCESS == rc);
+    test_verify("value after overwrite is new value", value == val_c);
+    /* size stays the same after overwrite */
+    test_verify("get_size unchanged after overwrite", 3 == opal_hash_table_get_size(&table));
+
+    /* remove one key and verify */
+    rc = opal_hash_table_remove_value_uint64(&table, UINT64_C(0xDEADBEEF00000002));
+    test_verify("remove uint64 key 2 succeeds", OPAL_SUCCESS == rc);
+    test_verify("get_size after remove", 2 == opal_hash_table_get_size(&table));
+    rc = opal_hash_table_get_value_uint64(&table, UINT64_C(0xDEADBEEF00000002), &value);
+    test_verify("removed uint64 key 2 not found", OPAL_ERR_NOT_FOUND == rc);
+
+    /* remove non-existent key */
+    rc = opal_hash_table_remove_value_uint64(&table, UINT64_C(0xDEADBEEF00000002));
+    test_verify("remove non-existent uint64 key returns error", OPAL_SUCCESS != rc);
+
+    /* traversal: get_first / get_next */
+    count = 0;
+    for (rc = opal_hash_table_get_first_key_uint64(&table, &key, &value, &node);
+         OPAL_SUCCESS == rc;
+         rc = opal_hash_table_get_next_key_uint64(&table, &key, &value, node, &node)) {
+        count++;
+    }
+    test_verify("uint64 traversal ends in OPAL_ERROR", OPAL_ERROR == rc);
+    test_verify("uint64 traversal visits all remaining keys", count == opal_hash_table_get_size(&table));
+
+    OBJ_DESTRUCT(&table);
+}
+
+/* Key buffers for ptr-key tests -- must outlive the table */
+static const char ptr_key1[] = "ptr-key-one";
+static const char ptr_key2[] = "ptr-key-two";
+static const char ptr_key3[] = "ptr-key-three";
+
+static void test_ptr_keys(void)
+{
+    opal_hash_table_t table;
+    void *key;
+    size_t key_size;
+    void *value;
+    void *node;
+    int rc;
+    size_t count;
+
+    fprintf(error_out, "\nTesting ptr key family (full)...\n");
+
+    OBJ_CONSTRUCT(&table, opal_hash_table_t);
+    opal_hash_table_init(&table, 8);
+
+    /* set */
+    rc = opal_hash_table_set_value_ptr(&table, ptr_key1, strlen(ptr_key1), val_a);
+    test_verify("set ptr key1 succeeds", OPAL_SUCCESS == rc);
+    rc = opal_hash_table_set_value_ptr(&table, ptr_key2, strlen(ptr_key2), val_b);
+    test_verify("set ptr key2 succeeds", OPAL_SUCCESS == rc);
+    rc = opal_hash_table_set_value_ptr(&table, ptr_key3, strlen(ptr_key3), val_c);
+    test_verify("set ptr key3 succeeds", OPAL_SUCCESS == rc);
+    test_verify("get_size after 3 ptr inserts", 3 == opal_hash_table_get_size(&table));
+
+    /* get */
+    rc = opal_hash_table_get_value_ptr(&table, ptr_key1, strlen(ptr_key1), &value);
+    test_verify("get ptr key1 found", OPAL_SUCCESS == rc);
+    test_verify("get ptr key1 value correct", value == val_a);
+
+    rc = opal_hash_table_get_value_ptr(&table, ptr_key2, strlen(ptr_key2), &value);
+    test_verify("get ptr key2 found", OPAL_SUCCESS == rc);
+    test_verify("get ptr key2 value correct", value == val_b);
+
+    /* get missing key */
+    rc = opal_hash_table_get_value_ptr(&table, "no-such-key", 11, &value);
+    test_verify("get missing ptr key returns not-found", OPAL_ERR_NOT_FOUND == rc);
+
+    /* overwrite */
+    rc = opal_hash_table_set_value_ptr(&table, ptr_key1, strlen(ptr_key1), val_b);
+    test_verify("overwrite ptr key1 succeeds", OPAL_SUCCESS == rc);
+    rc = opal_hash_table_get_value_ptr(&table, ptr_key1, strlen(ptr_key1), &value);
+    test_verify("get ptr key1 after overwrite", OPAL_SUCCESS == rc);
+    test_verify("ptr key1 value after overwrite is correct", value == val_b);
+    test_verify("size unchanged after ptr overwrite", 3 == opal_hash_table_get_size(&table));
+
+    /* remove */
+    rc = opal_hash_table_remove_value_ptr(&table, ptr_key2, strlen(ptr_key2));
+    test_verify("remove ptr key2 succeeds", OPAL_SUCCESS == rc);
+    test_verify("get_size after ptr remove", 2 == opal_hash_table_get_size(&table));
+    rc = opal_hash_table_get_value_ptr(&table, ptr_key2, strlen(ptr_key2), &value);
+    test_verify("removed ptr key2 not found", OPAL_ERR_NOT_FOUND == rc);
+
+    /* remove non-existent */
+    rc = opal_hash_table_remove_value_ptr(&table, ptr_key2, strlen(ptr_key2));
+    test_verify("remove non-existent ptr key returns error", OPAL_SUCCESS != rc);
+
+    /* traversal: get_first_key_ptr / get_next_key_ptr */
+    count = 0;
+    for (rc = opal_hash_table_get_first_key_ptr(&table, &key, &key_size, &value, &node);
+         OPAL_SUCCESS == rc;
+         rc = opal_hash_table_get_next_key_ptr(&table, &key, &key_size, &value, node, &node)) {
+        count++;
+    }
+    test_verify("ptr traversal ends in OPAL_ERROR", OPAL_ERROR == rc);
+    test_verify("ptr traversal visits all remaining keys",
+                count == opal_hash_table_get_size(&table));
+
+    /* remove_all then verify size */
+    opal_hash_table_remove_all(&table);
+    test_verify("get_size 0 after remove_all on ptr table", 0 == opal_hash_table_get_size(&table));
+
+    OBJ_DESTRUCT(&table);
+}
+
+static void test_init2_and_growth(void)
+{
+    opal_hash_table_t table;
+    size_t old_cap;
+    int i, rc;
+    char key_buf[64];
+    void *value;
+    int num_inserts = 200; /* enough to trigger at least one growth */
+
+    fprintf(error_out, "\nTesting opal_hash_table_init2 and table growth...\n");
+
+    OBJ_CONSTRUCT(&table, opal_hash_table_t);
+    /* non-default density: 3/4, growth factor: 2/1 */
+    rc = opal_hash_table_init2(&table, 8, 3, 4, 2, 1);
+    test_verify("opal_hash_table_init2 succeeds", OPAL_SUCCESS == rc);
+    test_verify("get_size after init2 is 0", 0 == opal_hash_table_get_size(&table));
+
+    old_cap = table.ht_capacity;
+
+    /* Insert enough uint64 keys to force growth */
+    for (i = 0; i < num_inserts; i++) {
+        rc = opal_hash_table_set_value_uint64(&table, (uint64_t) i, val_a);
+        test_verify("insert uint64 key during growth test", OPAL_SUCCESS == rc);
+    }
+    test_verify("get_size correct after many inserts",
+                (size_t) num_inserts == opal_hash_table_get_size(&table));
+    test_verify("capacity grew at least once", table.ht_capacity > old_cap);
+
+    /* verify all keys still retrievable */
+    for (i = 0; i < num_inserts; i++) {
+        rc = opal_hash_table_get_value_uint64(&table, (uint64_t) i, &value);
+        if (OPAL_SUCCESS != rc) {
+            snprintf(key_buf, sizeof(key_buf), "key %d not found after growth", i);
+            test_failure(key_buf);
+            break;
+        }
+    }
+    if (i == num_inserts) {
+        test_success();
+    }
+
+    /* remove_all */
+    opal_hash_table_remove_all(&table);
+    test_verify("get_size 0 after remove_all", 0 == opal_hash_table_get_size(&table));
+
+    OBJ_DESTRUCT(&table);
+}
+
 int main(int argc, char **argv)
 {
     int rc;
@@ -265,6 +472,9 @@ int main(int argc, char **argv)
 
     test_dynamic();
     test_static();
+    test_uint64_keys();
+    test_ptr_keys();
+    test_init2_and_growth();
 #ifndef STANDALONE
     fclose(error_out);
 #endif
diff --git a/test/class/opal_hotel.c b/test/class/opal_hotel.c
new file mode 100644
index 00000000000..ad283c1f409
--- /dev/null
+++ b/test/class/opal_hotel.c
@@ -0,0 +1,350 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for opal_hotel_t.  Exercises the full public API with
+ * self-checking assertions (via the support harness).  Note: the
+ * library is compiled with -DNDEBUG, so assert() is a no-op here --
+ * all verification must go through test_verify()/test_failure().
+ *
+ * We pass evbase=NULL throughout so that no libevent timers are armed.
+ * With evbase=NULL, checkin/checkout work entirely synchronously.
+ * A non-NULL evict_callback_fn is still required by opal_hotel_init().
+ */
+
+#include "opal_config.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include "support.h"
+
+#include "opal/class/opal_hotel.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+/* Trivial eviction callback -- never actually called in these tests
+   because evbase==NULL means no timer fires.  It must be non-NULL to
+   satisfy the bozo check inside opal_hotel_init(). */
+static void evict_cb(struct opal_hotel_t *hotel, int room_num, void *occupant)
+{
+    (void) hotel;
+    (void) room_num;
+    (void) occupant;
+    /* Should never be reached in these tests (evbase==NULL). */
+    test_failure("evict_cb: unexpected eviction callback invoked");
+}
+
+/* Opaque occupant payloads -- pointer identity only. */
+static int guests[16];
+#define GUEST(n) ((void *)&guests[(n)])
+
+static void test_init_errors(void);
+static void test_basic_checkin_checkout(void);
+static void test_checkout_and_return(void);
+static void test_is_empty(void);
+static void test_full_hotel(void);
+static void test_checkin_with_res(void);
+static void test_knock(void);
+static void test_checkout_empty_room(void);
+
+int main(int argc, char *argv[])
+{
+    /* Some opal_hotel error paths call opal_output(), which needs the
+       opal output/finalize infrastructure initialized. */
+    opal_init_util(&argc, &argv);
+
+    test_init("opal_hotel_t");
+
+    test_init_errors();
+    test_basic_checkin_checkout();
+    test_checkout_and_return();
+    test_is_empty();
+    test_full_hotel();
+    test_checkin_with_res();
+    test_knock();
+    test_checkout_empty_room();
+
+    int ret = test_finalize();
+    opal_finalize_util();
+    return ret;
+}
+
+/* --------------------------------------------------------------------------
+ * opal_hotel_init() error paths
+ * -------------------------------------------------------------------------- */
+static void test_init_errors(void)
+{
+    opal_hotel_t h;
+    int rc;
+
+    /* num_rooms == 0 is rejected */
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    rc = opal_hotel_init(&h, 0, NULL, 0, 0, evict_cb);
+    test_verify("init(num_rooms=0) -> BAD_PARAM", OPAL_ERR_BAD_PARAM == rc);
+    OBJ_DESTRUCT(&h);
+
+    /* num_rooms < 0 is rejected */
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    rc = opal_hotel_init(&h, -1, NULL, 0, 0, evict_cb);
+    test_verify("init(num_rooms=-1) -> BAD_PARAM", OPAL_ERR_BAD_PARAM == rc);
+    OBJ_DESTRUCT(&h);
+
+    /* NULL evict_callback_fn is rejected */
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    rc = opal_hotel_init(&h, 3, NULL, 0, 0, NULL);
+    test_verify("init(evict_fn=NULL) -> BAD_PARAM", OPAL_ERR_BAD_PARAM == rc);
+    OBJ_DESTRUCT(&h);
+
+    /* Valid parameters succeed */
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    rc = opal_hotel_init(&h, 3, NULL, 0, 0, evict_cb);
+    test_verify("init(3, NULL, 0, 0, cb) -> SUCCESS", OPAL_SUCCESS == rc);
+    OBJ_DESTRUCT(&h);
+}
+
+/* --------------------------------------------------------------------------
+ * Basic checkin / checkout sequence
+ * -------------------------------------------------------------------------- */
+static void test_basic_checkin_checkout(void)
+{
+    opal_hotel_t h;
+    int room[3];
+    int i, rc;
+
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    test_verify("init(3) ok", OPAL_SUCCESS == opal_hotel_init(&h, 3, NULL, 0, 0, evict_cb));
+
+    /* Check in three occupants; each must get a distinct, in-range room. */
+    for (i = 0; i < 3; ++i) {
+        room[i] = -1;
+        rc = opal_hotel_checkin(&h, GUEST(i), &room[i]);
+        test_verify("checkin -> SUCCESS", OPAL_SUCCESS == rc);
+        test_verify("room num in range [0, num_rooms)",
+                    room[i] >= 0 && room[i] < 3);
+    }
+
+    /* All three room numbers must be distinct. */
+    test_verify("room 0 != room 1", room[0] != room[1]);
+    test_verify("room 0 != room 2", room[0] != room[2]);
+    test_verify("room 1 != room 2", room[1] != room[2]);
+
+    /* Check out each room; afterwards a fresh checkin must succeed
+       (verifying the room was returned to the free pool). */
+    for (i = 0; i < 3; ++i) {
+        opal_hotel_checkout(&h, room[i]);
+    }
+
+    int new_room = -1;
+    rc = opal_hotel_checkin(&h, GUEST(5), &new_room);
+    test_verify("checkin after all checkouts -> SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("room from fresh checkin in range", new_room >= 0 && new_room < 3);
+    opal_hotel_checkout(&h, new_room);
+
+    OBJ_DESTRUCT(&h);
+}
+
+/* --------------------------------------------------------------------------
+ * checkout_and_return_occupant: verify occupant pointer is returned
+ * -------------------------------------------------------------------------- */
+static void test_checkout_and_return(void)
+{
+    opal_hotel_t h;
+    int room = -1;
+    void *out = NULL;
+
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    test_verify("init(2) ok", OPAL_SUCCESS == opal_hotel_init(&h, 2, NULL, 0, 0, evict_cb));
+
+    opal_hotel_checkin(&h, GUEST(7), &room);
+    test_verify("room is valid", room >= 0 && room < 2);
+
+    opal_hotel_checkout_and_return_occupant(&h, room, &out);
+    test_verify("returned occupant matches checked-in guest", GUEST(7) == out);
+
+    /* A second checkout from the same (now-empty) room must return NULL. */
+    out = GUEST(15); /* non-NULL sentinel distinct from GUEST(7) */
+    opal_hotel_checkout_and_return_occupant(&h, room, &out);
+    test_verify("checkout_and_return on empty room -> NULL occupant", NULL == out);
+
+    OBJ_DESTRUCT(&h);
+}
+
+/* --------------------------------------------------------------------------
+ * is_empty transitions
+ * -------------------------------------------------------------------------- */
+static void test_is_empty(void)
+{
+    opal_hotel_t h;
+    int r0 = -1, r1 = -1;
+
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    test_verify("init(2) ok", OPAL_SUCCESS == opal_hotel_init(&h, 2, NULL, 0, 0, evict_cb));
+
+    /* Fresh hotel is empty */
+    test_verify("fresh hotel is_empty == true", opal_hotel_is_empty(&h));
+
+    /* After first checkin, hotel is no longer empty */
+    opal_hotel_checkin(&h, GUEST(0), &r0);
+    test_verify("after first checkin is_empty == false", !opal_hotel_is_empty(&h));
+
+    /* After second checkin (all rooms occupied) still not empty */
+    opal_hotel_checkin(&h, GUEST(1), &r1);
+    test_verify("after both checkins is_empty == false", !opal_hotel_is_empty(&h));
+
+    /* Checkout one; not yet empty */
+    opal_hotel_checkout(&h, r0);
+    test_verify("after one checkout is_empty == false", !opal_hotel_is_empty(&h));
+
+    /* Checkout the other; now empty */
+    opal_hotel_checkout(&h, r1);
+    test_verify("after all checkouts is_empty == true", opal_hotel_is_empty(&h));
+
+    OBJ_DESTRUCT(&h);
+}
+
+/* --------------------------------------------------------------------------
+ * Checkin beyond capacity returns OPAL_ERR_TEMP_OUT_OF_RESOURCE
+ * -------------------------------------------------------------------------- */
+static void test_full_hotel(void)
+{
+    opal_hotel_t h;
+    int rooms[3];
+    int i, rc;
+
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    test_verify("init(3) ok", OPAL_SUCCESS == opal_hotel_init(&h, 3, NULL, 0, 0, evict_cb));
+
+    for (i = 0; i < 3; ++i) {
+        rooms[i] = -1;
+        rc = opal_hotel_checkin(&h, GUEST(i), &rooms[i]);
+        test_verify("fill: checkin -> SUCCESS", OPAL_SUCCESS == rc);
+    }
+
+    /* Hotel is full; one more checkin must fail. */
+    int overflow_room = -1;
+    rc = opal_hotel_checkin(&h, GUEST(9), &overflow_room);
+    test_verify("checkin when full -> TEMP_OUT_OF_RESOURCE",
+                OPAL_ERR_TEMP_OUT_OF_RESOURCE == rc);
+
+    /* Room variable must be untouched on failure (remains -1) */
+    test_verify("overflow room_num unchanged on failure", -1 == overflow_room);
+
+    /* Free one room; the next checkin must succeed. */
+    opal_hotel_checkout(&h, rooms[0]);
+    rc = opal_hotel_checkin(&h, GUEST(10), &rooms[0]);
+    test_verify("checkin after partial checkout -> SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("new room in range after partial checkout",
+                rooms[0] >= 0 && rooms[0] < 3);
+
+    /* Clean up remaining occupants */
+    for (i = 0; i < 3; ++i) {
+        opal_hotel_checkout(&h, rooms[i]);
+    }
+
+    OBJ_DESTRUCT(&h);
+}
+
+/* --------------------------------------------------------------------------
+ * checkin_with_res: optimized path for a caller that knows a room is free
+ * -------------------------------------------------------------------------- */
+static void test_checkin_with_res(void)
+{
+    opal_hotel_t h;
+    int room = -1;
+    void *out = NULL;
+
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    test_verify("init(2) ok", OPAL_SUCCESS == opal_hotel_init(&h, 2, NULL, 0, 0, evict_cb));
+
+    /* Use the with_res variant (caller asserts a room is available). */
+    opal_hotel_checkin_with_res(&h, GUEST(3), &room);
+    test_verify("checkin_with_res: room in range", room >= 0 && room < 2);
+
+    /* Verify occupant is actually present via checkout_and_return */
+    opal_hotel_checkout_and_return_occupant(&h, room, &out);
+    test_verify("checkin_with_res: occupant correct", GUEST(3) == out);
+
+    OBJ_DESTRUCT(&h);
+}
+
+/* --------------------------------------------------------------------------
+ * knock(): peek at a room without checking the occupant out
+ * -------------------------------------------------------------------------- */
+static void test_knock(void)
+{
+    opal_hotel_t h;
+    int room = -1;
+    void *out = NULL;
+
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    test_verify("init(2) ok", OPAL_SUCCESS == opal_hotel_init(&h, 2, NULL, 0, 0, evict_cb));
+
+    opal_hotel_checkin(&h, GUEST(6), &room);
+    test_verify("knock: room in range", room >= 0 && room < 2);
+
+    /* knock peeks at occupant but does NOT check them out */
+    opal_hotel_knock(&h, room, &out);
+    test_verify("knock returns correct occupant", GUEST(6) == out);
+
+    /* Occupant is still there -- a second knock sees the same value */
+    out = NULL;
+    opal_hotel_knock(&h, room, &out);
+    test_verify("knock is non-destructive (second knock)", GUEST(6) == out);
+
+    /* And checkout_and_return still works after two knocks */
+    out = NULL;
+    opal_hotel_checkout_and_return_occupant(&h, room, &out);
+    test_verify("occupant still present after knocks", GUEST(6) == out);
+
+    OBJ_DESTRUCT(&h);
+}
+
+/* --------------------------------------------------------------------------
+ * Checkout an already-empty room: must be a no-op (not crash or corrupt state)
+ * -------------------------------------------------------------------------- */
+static void test_checkout_empty_room(void)
+{
+    opal_hotel_t h;
+    int room = -1;
+    int rc;
+
+    OBJ_CONSTRUCT(&h, opal_hotel_t);
+    test_verify("init(2) ok", OPAL_SUCCESS == opal_hotel_init(&h, 2, NULL, 0, 0, evict_cb));
+
+    /* Checkin then checkout to get a valid room number in range */
+    rc = opal_hotel_checkin(&h, GUEST(0), &room);
+    test_verify("setup checkin ok", OPAL_SUCCESS == rc);
+    opal_hotel_checkout(&h, room);
+
+    /* Checkout same room again (already empty) -- the inline code has an
+       OPAL_LIKELY(room->occupant != NULL) guard, so it simply does nothing.
+       Verify the hotel state remains consistent: we can still checkin. */
+    opal_hotel_checkout(&h, room); /* no-op */
+
+    int new_room = -1;
+    rc = opal_hotel_checkin(&h, GUEST(1), &new_room);
+    test_verify("checkin after double-checkout still works", OPAL_SUCCESS == rc);
+    test_verify("room from checkin after double-checkout in range",
+                new_room >= 0 && new_room < 2);
+    opal_hotel_checkout(&h, new_room);
+
+    OBJ_DESTRUCT(&h);
+}
diff --git a/test/class/opal_interval_tree.c b/test/class/opal_interval_tree.c
new file mode 100644
index 00000000000..fc3e9f2ec1c
--- /dev/null
+++ b/test/class/opal_interval_tree.c
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2015-2018 Los Alamos National Security, LLC. All rights
+ *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for opal_interval_tree_t.  Exercises insert/find/delete,
+ * traversal, size/depth, structural verification and DOT dump.  The
+ * library is built with -DNDEBUG, so verification must use test_verify(),
+ * never assert().
+ */
+
+#include "opal_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "support.h"
+
+#include "opal/class/opal_interval_tree.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#define N 60
+
+/* Traverse action: count how many nodes the traversal visited. */
+static int count_action(uint64_t low, uint64_t high, void *data, void *ctx)
+{
+    (void) low;
+    (void) high;
+    (void) data;
+    int *counter = (int *) ctx;
+    (*counter)++;
+    return OPAL_SUCCESS;
+}
+
+/* Traverse action that aborts the traversal by returning an error. */
+static int abort_action(uint64_t low, uint64_t high, void *data, void *ctx)
+{
+    (void) low;
+    (void) high;
+    (void) data;
+    (void) ctx;
+    return OPAL_ERROR;
+}
+
+static void test_empty(void)
+{
+    opal_interval_tree_t tree;
+    OBJ_CONSTRUCT(&tree, opal_interval_tree_t);
+    test_verify("init empty tree", OPAL_SUCCESS == opal_interval_tree_init(&tree));
+
+    test_verify("empty size is 0", 0 == opal_interval_tree_size(&tree));
+    test_verify("empty find returns NULL", NULL == opal_interval_tree_find_overlapping(&tree, 5, 9));
+    test_verify("empty tree verifies", opal_interval_tree_verify(&tree));
+    test_verify("empty tree depth >= 1", opal_interval_tree_depth(&tree) >= 1);
+
+    OBJ_DESTRUCT(&tree);
+}
+
+static void test_insert_find(void)
+{
+    opal_interval_tree_t tree;
+    OBJ_CONSTRUCT(&tree, opal_interval_tree_t);
+    opal_interval_tree_init(&tree);
+
+    /* Insert N disjoint intervals [10*i, 10*i+5] with data = i+1. */
+    for (int i = 0; i < N; ++i) {
+        void *data = (void *) (intptr_t) (i + 1);
+        test_verify("insert ok",
+                    OPAL_SUCCESS == opal_interval_tree_insert(&tree, data, 10 * i, 10 * i + 5));
+    }
+    test_verify("size after inserts", N == (int) opal_interval_tree_size(&tree));
+    test_verify("tree verifies after inserts", opal_interval_tree_verify(&tree));
+
+    /* Exact-interval queries reliably locate their node. */
+    int found_all = 1;
+    for (int i = 0; i < N; ++i) {
+        void *expect = (void *) (intptr_t) (i + 1);
+        if (expect != opal_interval_tree_find_overlapping(&tree, 10 * i, 10 * i + 5)) {
+            found_all = 0;
+        }
+    }
+    test_verify("exact find returns inserted data", found_all);
+
+    /* A range that falls in a gap (not contained by any interval) is not
+       found. */
+    test_verify("gap range not found", NULL == opal_interval_tree_find_overlapping(&tree, 7, 8));
+
+    /* low > high is rejected. */
+    test_verify("insert low>high rejected",
+                OPAL_ERR_BAD_PARAM == opal_interval_tree_insert(&tree, (void *) 0x1, 50, 40));
+
+    OBJ_DESTRUCT(&tree);
+}
+
+static void test_traverse(void)
+{
+    opal_interval_tree_t tree;
+    int counter;
+    OBJ_CONSTRUCT(&tree, opal_interval_tree_t);
+    opal_interval_tree_init(&tree);
+
+    for (int i = 0; i < 10; ++i) {
+        opal_interval_tree_insert(&tree, (void *) (intptr_t) (i + 1), 10 * i, 10 * i + 5);
+    }
+
+    /* A traversal over the full range with partial_ok visits every node. */
+    counter = 0;
+    test_verify("traverse full range ok",
+                OPAL_SUCCESS
+                    == opal_interval_tree_traverse(&tree, 0, (uint64_t) -1, true, count_action,
+                                                   &counter));
+    test_verify("traverse visited all nodes", 10 == counter);
+
+    /* NULL action is rejected. */
+    test_verify("traverse NULL action rejected",
+                OPAL_ERR_BAD_PARAM
+                    == opal_interval_tree_traverse(&tree, 0, 100, true, NULL, NULL));
+
+    /* An action that returns an error aborts the traversal and propagates
+       the error code. */
+    test_verify("traverse propagates action error",
+                OPAL_ERROR
+                    == opal_interval_tree_traverse(&tree, 0, (uint64_t) -1, true, abort_action,
+                                                   NULL));
+
+    OBJ_DESTRUCT(&tree);
+}
+
+static void test_delete(void)
+{
+    opal_interval_tree_t tree;
+    OBJ_CONSTRUCT(&tree, opal_interval_tree_t);
+    opal_interval_tree_init(&tree);
+
+    for (int i = 0; i < N; ++i) {
+        opal_interval_tree_insert(&tree, (void *) (intptr_t) (i + 1), 10 * i, 10 * i + 5);
+    }
+
+    /* Deleting a non-existent interval reports NOT_FOUND. */
+    test_verify("delete missing -> NOT_FOUND",
+                OPAL_ERR_NOT_FOUND == opal_interval_tree_delete(&tree, 9999, 10000, NULL));
+
+    /* Delete every other interval by exact (low, high, data) match; this
+       forces both leaf and interior deletions plus rebalancing. */
+    int deleted = 0;
+    for (int i = 0; i < N; i += 2) {
+        void *data = (void *) (intptr_t) (i + 1);
+        if (OPAL_SUCCESS == opal_interval_tree_delete(&tree, 10 * i, 10 * i + 5, data)) {
+            deleted++;
+        }
+    }
+    test_verify("deleted expected count", deleted == (N + 1) / 2);
+    test_verify("size after deletes", (N - deleted) == (int) opal_interval_tree_size(&tree));
+    test_verify("tree verifies after deletes", opal_interval_tree_verify(&tree));
+
+    /* The remaining (odd-index) intervals are still findable; the deleted
+       ones are gone. */
+    int ok = 1;
+    for (int i = 1; i < N; i += 2) {
+        if ((void *) (intptr_t) (i + 1)
+            != opal_interval_tree_find_overlapping(&tree, 10 * i, 10 * i + 5)) {
+            ok = 0;
+        }
+    }
+    test_verify("remaining intervals still found", ok);
+
+    OBJ_DESTRUCT(&tree);
+}
+
+static void test_depth_and_dump(void)
+{
+    opal_interval_tree_t tree;
+    OBJ_CONSTRUCT(&tree, opal_interval_tree_t);
+    opal_interval_tree_init(&tree);
+
+    /* Insert in ascending order to force a long run of rotations. */
+    for (int i = 0; i < 63; ++i) {
+        opal_interval_tree_insert(&tree, (void *) (intptr_t) (i + 1), 10 * i, 10 * i + 5);
+    }
+
+    /* A red-black tree of 63 nodes must stay O(log n) deep; allow a
+       generous bound (2*log2(64) = 12, plus the root sentinel and slack). */
+    size_t depth = opal_interval_tree_depth(&tree);
+    test_verify("depth is O(log n)", depth >= 1 && depth <= 16);
+    test_verify("tree of 63 verifies", opal_interval_tree_verify(&tree));
+
+    /* DOT dump to a writable path succeeds; an unwritable path fails. */
+    char path[] = "/tmp/opal_itree_dumpXXXXXX";
+    int fd = mkstemp(path);
+    if (fd >= 0) {
+        close(fd);
+        test_verify("dump to file ok", OPAL_SUCCESS == opal_interval_tree_dump(&tree, path));
+        unlink(path);
+    }
+    test_verify("dump to bad path rejected",
+                OPAL_ERR_BAD_PARAM
+                    == opal_interval_tree_dump(&tree, "/nonexistent_dir_xyz/itree.dot"));
+
+    OBJ_DESTRUCT(&tree);
+}
+
+int main(int argc, char *argv[])
+{
+    /* opal_interval_tree uses an opal_free_list, which relies on
+       opal_cache_line_size and the MCA infrastructure being set up. */
+    opal_init_util(&argc, &argv);
+
+    test_init("opal_interval_tree_t");
+
+    test_empty();
+    test_insert_find();
+    test_traverse();
+    test_delete();
+    test_depth_and_dump();
+
+    int ret = test_finalize();
+    opal_finalize_util();
+    return ret;
+}
diff --git a/test/class/opal_list.c b/test/class/opal_list.c
index 714ab2714de..a2698015baa 100644
--- a/test/class/opal_list.c
+++ b/test/class/opal_list.c
@@ -10,6 +10,7 @@
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
  * Copyright (c) 2008-2014 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -19,6 +20,7 @@
 
 #include "opal_config.h"
 #include <assert.h>
+#include <stdlib.h>
 
 #include "opal/class/opal_list.h"
 #include "opal/constants.h"
@@ -37,6 +39,176 @@ typedef struct test_data {
 
 OBJ_CLASS_INSTANCE(test_data_t, opal_list_item_t, NULL, NULL);
 
+/* Comparator for opal_list_sort(): ascending order on test_data_t.data */
+static int compare_test_data(opal_list_item_t **a, opal_list_item_t **b)
+{
+    const test_data_t *da = (const test_data_t *) *a;
+    const test_data_t *db = (const test_data_t *) *b;
+    if (da->data < db->data) {
+        return -1;
+    } else if (da->data > db->data) {
+        return 1;
+    }
+    return 0;
+}
+
+static void test_sort(void)
+{
+    opal_list_t slist;
+    test_data_t items[5];
+    test_data_t *ele;
+    size_t expected_order[] = {0, 1, 2, 3, 4};
+    /* Insert in reverse order so sort is non-trivial */
+    size_t insert_order[] = {4, 2, 0, 3, 1};
+    size_t n = 5;
+    size_t i;
+    int rc;
+    size_t idx;
+
+    OBJ_CONSTRUCT(&slist, opal_list_t);
+    for (i = 0; i < n; i++) {
+        OBJ_CONSTRUCT(&items[i], test_data_t);
+        items[i].data = insert_order[i];
+        opal_list_append(&slist, (opal_list_item_t *) &items[i]);
+    }
+    test_verify("sort: list has correct size before sort",
+                n == opal_list_get_size(&slist));
+
+    rc = opal_list_sort(&slist, compare_test_data);
+    test_verify("opal_list_sort returns success", OPAL_SUCCESS == rc);
+    test_verify("sort: list size unchanged after sort",
+                n == opal_list_get_size(&slist));
+
+    /* Verify order is ascending */
+    idx = 0;
+    OPAL_LIST_FOREACH(ele, &slist, test_data_t) {
+        test_verify("sort: element in correct ascending position",
+                    ele->data == expected_order[idx]);
+        idx++;
+    }
+    test_verify("sort: iterated correct number of elements", idx == n);
+
+    /* Remove all items before destructing (items are stack-allocated) */
+    while (!opal_list_is_empty(&slist)) {
+        opal_list_remove_first(&slist);
+    }
+    OBJ_DESTRUCT(&slist);
+    for (i = 0; i < n; i++) {
+        OBJ_DESTRUCT(&items[i]);
+    }
+}
+
+static void test_insert_pos(void)
+{
+    opal_list_t ilist;
+    test_data_t items[4];
+    test_data_t *ele;
+    opal_list_item_t *pos;
+    size_t i;
+    size_t idx;
+
+    /* Build list: 0 -> 1 -> 2, then insert 99 before item[1] */
+    OBJ_CONSTRUCT(&ilist, opal_list_t);
+    for (i = 0; i < 3; i++) {
+        OBJ_CONSTRUCT(&items[i], test_data_t);
+        items[i].data = i;
+        opal_list_append(&ilist, (opal_list_item_t *) &items[i]);
+    }
+    OBJ_CONSTRUCT(&items[3], test_data_t);
+    items[3].data = 99;
+
+    /* pos = item at index 1 (data==1) */
+    pos = opal_list_get_next(opal_list_get_first(&ilist));
+    opal_list_insert_pos(&ilist, pos, (opal_list_item_t *) &items[3]);
+
+    test_verify("insert_pos: list size after insert", 4 == opal_list_get_size(&ilist));
+
+    /* Expected order: 0, 99, 1, 2 */
+    {
+        size_t expected[] = {0, 99, 1, 2};
+        idx = 0;
+        OPAL_LIST_FOREACH(ele, &ilist, test_data_t) {
+            test_verify("insert_pos: element order correct",
+                        ele->data == expected[idx]);
+            idx++;
+        }
+        test_verify("insert_pos: iterated correct count", idx == 4);
+    }
+
+    while (!opal_list_is_empty(&ilist)) {
+        opal_list_remove_first(&ilist);
+    }
+    OBJ_DESTRUCT(&ilist);
+    for (i = 0; i < 4; i++) {
+        OBJ_DESTRUCT(&items[i]);
+    }
+}
+
+static void test_foreach_macros(void)
+{
+    opal_list_t flist;
+    test_data_t items[4];
+    test_data_t *ele, *next;
+    size_t n = 4;
+    size_t i;
+    size_t fwd_count, rev_count;
+
+    OBJ_CONSTRUCT(&flist, opal_list_t);
+    for (i = 0; i < n; i++) {
+        OBJ_CONSTRUCT(&items[i], test_data_t);
+        items[i].data = i;
+        opal_list_append(&flist, (opal_list_item_t *) &items[i]);
+    }
+
+    /* OPAL_LIST_FOREACH forward */
+    fwd_count = 0;
+    i = 0;
+    OPAL_LIST_FOREACH(ele, &flist, test_data_t) {
+        test_verify("FOREACH: element data matches forward order", ele->data == i);
+        fwd_count++;
+        i++;
+    }
+    test_verify("FOREACH: visited all elements", fwd_count == n);
+
+    /* OPAL_LIST_FOREACH_REV */
+    rev_count = 0;
+    i = n;
+    OPAL_LIST_FOREACH_REV(ele, &flist, test_data_t) {
+        i--;
+        test_verify("FOREACH_REV: element data matches reverse order", ele->data == i);
+        rev_count++;
+    }
+    test_verify("FOREACH_REV: visited all elements", rev_count == n);
+
+    /* OPAL_LIST_FOREACH_SAFE: remove even-data items while iterating */
+    OPAL_LIST_FOREACH_SAFE(ele, next, &flist, test_data_t) {
+        if (0 == ele->data % 2) {
+            opal_list_remove_item(&flist, (opal_list_item_t *) ele);
+        }
+    }
+    /* For n=4 we removed items with data 0 and 2; remaining: 1, 3 */
+    test_verify("FOREACH_SAFE: list size after safe removal",
+                2 == opal_list_get_size(&flist));
+    {
+        size_t expected[] = {1, 3};
+        size_t idx = 0;
+        OPAL_LIST_FOREACH(ele, &flist, test_data_t) {
+            test_verify("FOREACH_SAFE: remaining elements correct",
+                        ele->data == expected[idx]);
+            idx++;
+        }
+        test_verify("FOREACH_SAFE: iterated remaining count", idx == 2);
+    }
+
+    while (!opal_list_is_empty(&flist)) {
+        opal_list_remove_first(&flist);
+    }
+    OBJ_DESTRUCT(&flist);
+    for (i = 0; i < n; i++) {
+        OBJ_DESTRUCT(&items[i]);
+    }
+}
+
 int main(int argc, char **argv)
 {
     /* local variables */
@@ -306,6 +478,11 @@ int main(int argc, char **argv)
     if (NULL != elements)
         free(elements);
 
+    /* Additional coverage tests */
+    test_sort();
+    test_insert_pos();
+    test_foreach_macros();
+
     opal_finalize_util();
 
     return test_finalize();
diff --git a/test/class/opal_pointer_array.c b/test/class/opal_pointer_array.c
index b0ce90b2a53..8e0242a17e3 100644
--- a/test/class/opal_pointer_array.c
+++ b/test/class/opal_pointer_array.c
@@ -11,6 +11,7 @@
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
  * Copyright (c) 2010      Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -155,9 +156,25 @@ static void test(bool thread_usage)
             if (0 != opal_pointer_array_set_item(array, i, NULL))
                 test_failure("Add/Remove: failure during item removal ");
     }
+    /*
+     * Re-add up to 4 items.  The array was init'd with max_size=4;
+     * after the removals above (indices 1 and 3 freed), exactly 2 slots
+     * are available.  So the first 2 adds succeed (returning >= 0) and
+     * the last 2 fail because the array is at max capacity (returning -1).
+     *
+     * PRE-EXISTING BUG FIXED:
+     *   Original code used `if (!opal_pointer_array_add(...))` which
+     *   treats the return value as a boolean -- this incorrectly reports
+     *   a failure when index 0 is returned (because !0 == true).
+     *   Changed to `< 0` to check for the documented error sentinel.
+     *
+     *   The guard was also wrong: `if (i != 2)` only excuses the i==2
+     *   failure; the i==3 failure (same root cause: at max capacity)
+     *   was incorrectly reported as a test failure.  Changed to `i >= 2`.
+     */
     for (i = 0; i < 4; i++) {
-        if (!opal_pointer_array_add(array, (void *) (uintptr_t)(i + 1))) {
-            if (i != 2) {
+        if (0 > opal_pointer_array_add(array, (void *) (uintptr_t)(i + 1))) {
+            if (i < 2) {
                 test_failure("Add/Remove: failure during the readd ");
                 break;
             }
@@ -170,6 +187,73 @@ static void test(bool thread_usage)
     free(test_data);
 }
 
+static void test_set_size_and_get_size(void)
+{
+    opal_pointer_array_t *array;
+    int rc;
+    int initial_size;
+
+    array = OBJ_NEW(opal_pointer_array_t);
+    opal_pointer_array_init(array, 4, 64, 4);
+
+    initial_size = opal_pointer_array_get_size(array);
+    test_verify("get_size returns initial allocation size", initial_size == 4);
+
+    /* Grow the array via set_size */
+    rc = opal_pointer_array_set_size(array, 16);
+    test_verify("set_size to larger value succeeds", OPAL_SUCCESS == rc);
+    test_verify("get_size reflects new size", opal_pointer_array_get_size(array) >= 16);
+
+    /* set_size to the same value should be a no-op (no error) */
+    rc = opal_pointer_array_set_size(array, 16);
+    test_verify("set_size to same value succeeds", OPAL_SUCCESS == rc);
+
+    /* set_size to a smaller value: documented to succeed without shrinking */
+    rc = opal_pointer_array_set_size(array, 2);
+    test_verify("set_size to smaller value succeeds", OPAL_SUCCESS == rc);
+
+    OBJ_RELEASE(array);
+}
+
+static void test_test_and_set_item(void)
+{
+    opal_pointer_array_t *array;
+    bool ok;
+    void *sentinel_a = (void *) (uintptr_t) 0xABCD;
+    void *sentinel_b = (void *) (uintptr_t) 0xEF01;
+
+    array = OBJ_NEW(opal_pointer_array_t);
+    opal_pointer_array_init(array, 4, 64, 4);
+
+    /* Slot 2 is free: test_and_set should succeed */
+    ok = opal_pointer_array_test_and_set_item(array, 2, sentinel_a);
+    test_verify("test_and_set on free slot returns true", ok == true);
+    test_verify("test_and_set stored correct value",
+                opal_pointer_array_get_item(array, 2) == sentinel_a);
+
+    /* Slot 2 is now occupied: test_and_set should fail */
+    ok = opal_pointer_array_test_and_set_item(array, 2, sentinel_b);
+    test_verify("test_and_set on occupied slot returns false", ok == false);
+    /* value should be unchanged */
+    test_verify("test_and_set did not overwrite occupied slot",
+                opal_pointer_array_get_item(array, 2) == sentinel_a);
+
+    /* test_and_set at an index beyond current size (auto-grow) */
+    ok = opal_pointer_array_test_and_set_item(array, 10, sentinel_b);
+    test_verify("test_and_set beyond current size grows array", ok == true);
+    test_verify("test_and_set at grown index has correct value",
+                opal_pointer_array_get_item(array, 10) == sentinel_b);
+
+    /* After freeing slot 2 (set to NULL), test_and_set should succeed again */
+    opal_pointer_array_set_item(array, 2, NULL);
+    ok = opal_pointer_array_test_and_set_item(array, 2, sentinel_b);
+    test_verify("test_and_set on newly-freed slot returns true", ok == true);
+    test_verify("test_and_set after free has new value",
+                opal_pointer_array_get_item(array, 2) == sentinel_b);
+
+    OBJ_RELEASE(array);
+}
+
 int main(int argc, char **argv)
 {
     test_init("opal_pointer_array");
@@ -180,5 +264,9 @@ int main(int argc, char **argv)
     /* run through tests with thread usage set to true */
     test(true);
 
+    /* Additional API coverage */
+    test_set_size_and_get_size();
+    test_test_and_set_item();
+
     return test_finalize();
 }
diff --git a/test/class/ompi_rb_tree.c b/test/class/opal_rb_tree.c
similarity index 100%
rename from test/class/ompi_rb_tree.c
rename to test/class/opal_rb_tree.c
diff --git a/test/class/opal_ring_buffer.c b/test/class/opal_ring_buffer.c
new file mode 100644
index 00000000000..13a1059f75d
--- /dev/null
+++ b/test/class/opal_ring_buffer.c
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for opal_ring_buffer_t.  Exercises the full public API with
+ * self-checking assertions (via the support harness).  Note: the
+ * library is compiled with -DNDEBUG, so assert() is a no-op here --
+ * all verification must go through test_verify()/test_failure().
+ */
+
+#include "opal_config.h"
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "support.h"
+
+#include "opal/class/opal_ring_buffer.h"
+#include "opal/constants.h"
+
+/* Use addresses of static ints as opaque void* payloads -- pointer
+   identity only, no heap allocation needed.  A large pool covers all
+   tests without reuse confusion. */
+static int items[32];
+
+/* Shorthand: item pointer */
+#define ITEM(n) ((void *)&items[(n)])
+
+static void test_init_error(void);
+static void test_push_and_pop_basic(void);
+static void test_push_eviction_wraparound(void);
+static void test_poke(void);
+static void test_pop_empty(void);
+
+int main(int argc, char *argv[])
+{
+    test_init("opal_ring_buffer_t");
+
+    test_init_error();
+    test_push_and_pop_basic();
+    test_push_eviction_wraparound();
+    test_poke();
+    test_pop_empty();
+
+    return test_finalize();
+}
+
+/* --------------------------------------------------------------------------
+ * init error paths
+ * -------------------------------------------------------------------------- */
+static void test_init_error(void)
+{
+    /* NULL ring pointer must return OPAL_ERR_BAD_PARAM */
+    test_verify("init(NULL) returns BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == opal_ring_buffer_init(NULL, 4));
+}
+
+/* --------------------------------------------------------------------------
+ * Basic push-pop FIFO ordering (no wraparound / eviction)
+ * -------------------------------------------------------------------------- */
+static void test_push_and_pop_basic(void)
+{
+    opal_ring_buffer_t rb;
+    void *ret;
+
+    OBJ_CONSTRUCT(&rb, opal_ring_buffer_t);
+    test_verify("init(3) ok", OPAL_SUCCESS == opal_ring_buffer_init(&rb, 3));
+
+    /* Push three items into a 3-slot ring -- no slot is overwritten yet,
+       so push must return NULL (no evicted occupant). */
+    ret = opal_ring_buffer_push(&rb, ITEM(0));
+    test_verify("push A into empty slot -> NULL", NULL == ret);
+
+    ret = opal_ring_buffer_push(&rb, ITEM(1));
+    test_verify("push B into empty slot -> NULL", NULL == ret);
+
+    ret = opal_ring_buffer_push(&rb, ITEM(2));
+    test_verify("push C into empty slot -> NULL", NULL == ret);
+
+    /* Pop should return items FIFO -- oldest first: A, B, C */
+    test_verify("pop returns oldest (A)", ITEM(0) == opal_ring_buffer_pop(&rb));
+    test_verify("pop returns next   (B)", ITEM(1) == opal_ring_buffer_pop(&rb));
+    test_verify("pop returns newest (C)", ITEM(2) == opal_ring_buffer_pop(&rb));
+
+    /* Ring is now empty */
+    test_verify("pop on empty -> NULL", NULL == opal_ring_buffer_pop(&rb));
+
+    OBJ_DESTRUCT(&rb);
+}
+
+/* --------------------------------------------------------------------------
+ * Push-when-full: eviction and FIFO ordering after wrap-around
+ *
+ * After filling a 3-slot ring (A, B, C), pushing D must evict A (the
+ * oldest / tail element) and return it.  The ring then contains B, C, D
+ * oldest-to-newest.
+ *
+ * NOTE: The function header comment says push "returns error if ring cannot
+ * take another entry", yet the C signature is void* and the implementation
+ * returns the evicted pointer (not an error code).  The void* return is the
+ * authoritative contract; the header @return text is misleading.
+ *
+ * SUSPECTED BUG: header @return text says "returns error if ring cannot
+ * take another entry" but the function signature is void* and the
+ * implementation returns the evicted occupant (or NULL for a free slot).
+ * The text contradicts the actual void* contract.
+ * -------------------------------------------------------------------------- */
+static void test_push_eviction_wraparound(void)
+{
+    opal_ring_buffer_t rb;
+    void *evicted;
+
+    OBJ_CONSTRUCT(&rb, opal_ring_buffer_t);
+    test_verify("init(3) ok", OPAL_SUCCESS == opal_ring_buffer_init(&rb, 3));
+
+    /* Fill the ring: A at slot0, B at slot1, C at slot2. */
+    opal_ring_buffer_push(&rb, ITEM(10)); /* A */
+    opal_ring_buffer_push(&rb, ITEM(11)); /* B */
+    opal_ring_buffer_push(&rb, ITEM(12)); /* C */
+
+    /* Pushing D into a full ring must evict and return A (oldest). */
+    evicted = opal_ring_buffer_push(&rb, ITEM(13)); /* D evicts A */
+    test_verify("push into full -> evicts oldest (A)", ITEM(10) == evicted);
+
+    /* Ring now: B, C, D (oldest to newest). */
+    test_verify("pop after eviction -> B", ITEM(11) == opal_ring_buffer_pop(&rb));
+    test_verify("pop after eviction -> C", ITEM(12) == opal_ring_buffer_pop(&rb));
+    test_verify("pop after eviction -> D", ITEM(13) == opal_ring_buffer_pop(&rb));
+    test_verify("pop on empty after eviction -> NULL", NULL == opal_ring_buffer_pop(&rb));
+
+    /* Verify multiple wrap-arounds: push 6 items into an empty size-3 ring.
+       After 6 pushes the ring should hold items 23,24,25 (newest three). */
+    opal_ring_buffer_push(&rb, ITEM(20)); /* evicts nothing (empty) */
+    opal_ring_buffer_push(&rb, ITEM(21));
+    opal_ring_buffer_push(&rb, ITEM(22));
+    opal_ring_buffer_push(&rb, ITEM(23)); /* evicts ITEM(20) */
+    opal_ring_buffer_push(&rb, ITEM(24)); /* evicts ITEM(21) */
+    opal_ring_buffer_push(&rb, ITEM(25)); /* evicts ITEM(22) */
+
+    test_verify("wrap: pop -> item 23", ITEM(23) == opal_ring_buffer_pop(&rb));
+    test_verify("wrap: pop -> item 24", ITEM(24) == opal_ring_buffer_pop(&rb));
+    test_verify("wrap: pop -> item 25", ITEM(25) == opal_ring_buffer_pop(&rb));
+    test_verify("wrap: pop on empty -> NULL", NULL == opal_ring_buffer_pop(&rb));
+
+    OBJ_DESTRUCT(&rb);
+}
+
+/* --------------------------------------------------------------------------
+ * poke(): non-destructive index into the ring
+ *
+ * poke(i>=0): return element i positions forward from the tail (oldest).
+ * poke(i<0):  return the element at the head - 1, i.e., the newest item.
+ * poke(i>=size): return NULL.
+ * poke on empty ring: return NULL regardless of index.
+ * -------------------------------------------------------------------------- */
+static void test_poke(void)
+{
+    opal_ring_buffer_t rb;
+
+    OBJ_CONSTRUCT(&rb, opal_ring_buffer_t);
+    test_verify("init(4) ok", OPAL_SUCCESS == opal_ring_buffer_init(&rb, 4));
+
+    /* poke on an empty ring must return NULL for any index */
+    test_verify("poke(0) on empty -> NULL", NULL == opal_ring_buffer_poke(&rb, 0));
+    test_verify("poke(-1) on empty -> NULL", NULL == opal_ring_buffer_poke(&rb, -1));
+    test_verify("poke(3) on empty -> NULL", NULL == opal_ring_buffer_poke(&rb, 3));
+
+    /* Push 4 items: A=ITEM(0), B=ITEM(1), C=ITEM(2), D=ITEM(3) */
+    opal_ring_buffer_push(&rb, ITEM(0)); /* A, oldest */
+    opal_ring_buffer_push(&rb, ITEM(1)); /* B */
+    opal_ring_buffer_push(&rb, ITEM(2)); /* C */
+    opal_ring_buffer_push(&rb, ITEM(3)); /* D, newest */
+
+    /* poke by non-negative offset from tail (oldest) */
+    test_verify("poke(0) -> oldest (A)", ITEM(0) == opal_ring_buffer_poke(&rb, 0));
+    test_verify("poke(1) -> B",          ITEM(1) == opal_ring_buffer_poke(&rb, 1));
+    test_verify("poke(2) -> C",          ITEM(2) == opal_ring_buffer_poke(&rb, 2));
+    test_verify("poke(3) -> newest (D)", ITEM(3) == opal_ring_buffer_poke(&rb, 3));
+
+    /* poke(-1) returns the element at head-1 = newest */
+    test_verify("poke(-1) -> newest (D)", ITEM(3) == opal_ring_buffer_poke(&rb, -1));
+
+    /* poke with index >= size returns NULL */
+    test_verify("poke(4) -> NULL (i >= size)", NULL == opal_ring_buffer_poke(&rb, 4));
+    test_verify("poke(99) -> NULL (i >> size)", NULL == opal_ring_buffer_poke(&rb, 99));
+
+    /* After push-eviction the ring wraps; poke must still work correctly.
+       Push E (evicts A): ring is B,C,D,E oldest-to-newest. */
+    opal_ring_buffer_push(&rb, ITEM(4)); /* E evicts A */
+
+    test_verify("poke(0) after wrap -> B", ITEM(1) == opal_ring_buffer_poke(&rb, 0));
+    test_verify("poke(3) after wrap -> E", ITEM(4) == opal_ring_buffer_poke(&rb, 3));
+    test_verify("poke(-1) after wrap -> E (newest)", ITEM(4) == opal_ring_buffer_poke(&rb, -1));
+
+    /* poke does NOT remove; pop should still deliver items in FIFO order */
+    test_verify("poke does not remove: pop -> B", ITEM(1) == opal_ring_buffer_pop(&rb));
+    test_verify("poke does not remove: pop -> C", ITEM(2) == opal_ring_buffer_pop(&rb));
+    test_verify("poke does not remove: pop -> D", ITEM(3) == opal_ring_buffer_pop(&rb));
+    test_verify("poke does not remove: pop -> E", ITEM(4) == opal_ring_buffer_pop(&rb));
+
+    OBJ_DESTRUCT(&rb);
+}
+
+/* --------------------------------------------------------------------------
+ * pop from empty ring always returns NULL
+ * -------------------------------------------------------------------------- */
+static void test_pop_empty(void)
+{
+    opal_ring_buffer_t rb;
+
+    OBJ_CONSTRUCT(&rb, opal_ring_buffer_t);
+    test_verify("init(1) ok", OPAL_SUCCESS == opal_ring_buffer_init(&rb, 1));
+
+    /* Freshly initialised, tail == -1 -> empty */
+    test_verify("pop from fresh empty ring -> NULL", NULL == opal_ring_buffer_pop(&rb));
+
+    /* Push one item, pop it, then pop again -- ring is empty */
+    opal_ring_buffer_push(&rb, ITEM(5));
+    opal_ring_buffer_pop(&rb);
+    test_verify("pop from drained ring -> NULL", NULL == opal_ring_buffer_pop(&rb));
+
+    OBJ_DESTRUCT(&rb);
+}
diff --git a/test/class/opal_value_array.c b/test/class/opal_value_array.c
index 2145e2fabc4..33302b22803 100644
--- a/test/class/opal_value_array.c
+++ b/test/class/opal_value_array.c
@@ -10,6 +10,7 @@
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
  * Copyright (c) 2008-2014 Cisco Systems, Inc.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -113,6 +114,112 @@ int main(int argc, char **argv)
 
     OBJ_DESTRUCT(&array);
 
+    /* ------- Additional coverage tests ------- */
+
+    /* opal_value_array_reserve: reserve should grow alloc without changing size */
+    {
+        opal_value_array_t ra;
+        int rc;
+
+        OBJ_CONSTRUCT(&ra, opal_value_array_t);
+        opal_value_array_init(&ra, sizeof(uint64_t));
+
+        rc = opal_value_array_reserve(&ra, 50);
+        test_verify("opal_value_array_reserve succeeds", OPAL_SUCCESS == rc);
+        test_verify("reserve grows allocated capacity", ra.array_alloc_size >= 50);
+        test_verify("reserve does not change logical size", 0 == opal_value_array_get_size(&ra));
+
+        /* reserving a smaller size is a no-op */
+        rc = opal_value_array_reserve(&ra, 1);
+        test_verify("reserve smaller is a no-op (succeeds)", OPAL_SUCCESS == rc);
+        test_verify("reserve smaller does not shrink alloc", ra.array_alloc_size >= 50);
+
+        OBJ_DESTRUCT(&ra);
+    }
+
+    /* opal_value_array_get_item auto-grow path */
+    {
+        opal_value_array_t ga;
+        void *ptr;
+        uint64_t *uptr;
+
+        OBJ_CONSTRUCT(&ga, opal_value_array_t);
+        opal_value_array_init(&ga, sizeof(uint64_t));
+
+        /* index 9 is beyond current size (0); get_item should auto-grow */
+        ptr = opal_value_array_get_item(&ga, 9);
+        test_verify("get_item auto-grows array when index beyond size",
+                    NULL != ptr);
+        test_verify("get_item auto-grow updates logical size",
+                    opal_value_array_get_size(&ga) >= 10);
+
+        /* write to the returned pointer and read it back via GET_ITEM */
+        uptr = (uint64_t *) ptr;
+        *uptr = UINT64_C(0xCAFEBABE);
+        test_verify("get_item auto-grow: stored value readable via GET_ITEM",
+                    UINT64_C(0xCAFEBABE) == OPAL_VALUE_ARRAY_GET_ITEM(&ga, uint64_t, 9));
+
+        OBJ_DESTRUCT(&ga);
+    }
+
+    /* opal_value_array_set_item (function, not macro) with auto-grow */
+    {
+        opal_value_array_t si;
+        uint64_t wval, rval;
+        int rc;
+
+        OBJ_CONSTRUCT(&si, opal_value_array_t);
+        opal_value_array_init(&si, sizeof(uint64_t));
+
+        wval = UINT64_C(0x1234567890ABCDEF);
+        rc = opal_value_array_set_item(&si, 5, &wval);
+        test_verify("set_item auto-grows and succeeds", OPAL_SUCCESS == rc);
+        test_verify("set_item auto-grow updates logical size",
+                    opal_value_array_get_size(&si) >= 6);
+
+        rval = OPAL_VALUE_ARRAY_GET_ITEM(&si, uint64_t, 5);
+        test_verify("set_item stored correct value", rval == wval);
+
+        /* overwrite an existing index */
+        wval = UINT64_C(0xDEADBEEF);
+        rc = opal_value_array_set_item(&si, 5, &wval);
+        test_verify("set_item overwrite succeeds", OPAL_SUCCESS == rc);
+        rval = OPAL_VALUE_ARRAY_GET_ITEM(&si, uint64_t, 5);
+        test_verify("set_item overwrite stored new value", rval == wval);
+
+        OBJ_DESTRUCT(&si);
+    }
+
+    /* OPAL_VALUE_ARRAY_GET_BASE */
+    {
+        opal_value_array_t ba;
+        uint64_t *base;
+        size_t j;
+
+        OBJ_CONSTRUCT(&ba, opal_value_array_t);
+        opal_value_array_init(&ba, sizeof(uint64_t));
+        opal_value_array_set_size(&ba, 8);
+        for (j = 0; j < 8; j++) {
+            OPAL_VALUE_ARRAY_SET_ITEM(&ba, uint64_t, j, (uint64_t) (j * 10));
+        }
+
+        base = OPAL_VALUE_ARRAY_GET_BASE(&ba, uint64_t);
+        test_verify("OPAL_VALUE_ARRAY_GET_BASE returns non-NULL pointer",
+                    NULL != base);
+        {
+            int all_ok = 1;
+            for (j = 0; j < 8; j++) {
+                if (base[j] != (uint64_t) (j * 10)) {
+                    all_ok = 0;
+                }
+            }
+            test_verify("OPAL_VALUE_ARRAY_GET_BASE elements match SET_ITEM values",
+                        1 == all_ok);
+        }
+
+        OBJ_DESTRUCT(&ba);
+    }
+
     opal_finalize_util();
 
     return test_finalize();
diff --git a/test/datatype/Makefile.am b/test/datatype/Makefile.am
index 3d6fd3289b5..04b2bdcafea 100644
--- a/test/datatype/Makefile.am
+++ b/test/datatype/Makefile.am
@@ -7,88 +7,36 @@
 # Copyright (c) 2014-2019 Research Organization for Information Science
 #                         and Technology (RIST).  All rights reserved.
 # Copyright (c) 2016      IBM Corporation.  All rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
 #
 # $HEADER$
 #
+# OPAL-level datatype tests: these link only against libopen-pal.  The
+# tests of the OMPI datatype engine and the MPI datatype API live in
+# ompi/test/datatype.
+#
 
-if PROJECT_OMPI
-    MPI_TESTS = checksum position position_noncontig ddt_test ddt_raw ddt_raw2 unpack_ooo ddt_pack external32 large_data partial
-    MPI_CHECKS = to_self reduce_local
-endif
-TESTS = opal_datatype_test unpack_hetero $(MPI_TESTS)
-
-check_PROGRAMS = $(TESTS) $(MPI_CHECKS)
-
-unpack_ooo_SOURCES = unpack_ooo.c ddt_lib.c ddt_lib.h
-unpack_ooo_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-unpack_ooo_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-
-ddt_test_SOURCES = ddt_test.c ddt_lib.c ddt_lib.h
-ddt_test_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-ddt_test_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-
-ddt_raw_SOURCES = ddt_raw.c ddt_lib.c ddt_lib.h
-ddt_raw_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-ddt_raw_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-
-ddt_raw2_SOURCES = ddt_raw2.c ddt_lib.c ddt_lib.h
-ddt_raw2_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-ddt_raw2_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-
-ddt_pack_SOURCES = ddt_pack.c
-ddt_pack_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-ddt_pack_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-
-checksum_SOURCES = checksum.c
-checksum_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-checksum_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-
-position_SOURCES = position.c
-position_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-position_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+AM_CPPFLAGS = -I$(top_srcdir)/test/support
 
-position_noncontig_SOURCES = position_noncontig.c
-position_noncontig_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-position_noncontig_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+# These tests call opal_init().  Make "make check" work in an
+# uninstalled --enable-mca-dso build tree.
+include $(top_srcdir)/Makefile.mca-dso-check
 
-to_self_SOURCES = to_self.c
-to_self_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-to_self_LDADD = $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la
+TESTS = opal_datatype_test opal_datatype_bigcount unpack_hetero opal_ddt_api
 
-large_data_SOURCES = large_data.c
-large_data_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-large_data_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+check_PROGRAMS = $(TESTS)
 
 opal_datatype_test_SOURCES = opal_datatype_test.c opal_ddt_lib.c opal_ddt_lib.h
 opal_datatype_test_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
 opal_datatype_test_LDADD = \
         $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
 
-external32_SOURCES = external32.c
-external32_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-external32_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
+opal_datatype_bigcount_SOURCES = opal_datatype_bigcount.c
+opal_datatype_bigcount_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+opal_datatype_bigcount_LDADD = \
         $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
 
 unpack_hetero_SOURCES = unpack_hetero.c
@@ -96,17 +44,11 @@ unpack_hetero_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
 unpack_hetero_LDADD = \
         $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
 
-reduce_local_SOURCES = reduce_local.c
-reduce_local_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-reduce_local_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-
-partial_SOURCES = partial.c
-partial_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-partial_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
+opal_ddt_api_SOURCES = opal_ddt_api.c
+opal_ddt_api_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
+opal_ddt_api_LDADD = \
+        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
+        $(top_builddir)/test/support/libsupport.a
 
 distclean-local:
 	rm -rf *.dSYM .deps .libs *.log *.o *.trs $(check_PROGRAMS) Makefile
diff --git a/test/datatype/opal_datatype_bigcount.c b/test/datatype/opal_datatype_bigcount.c
new file mode 100644
index 00000000000..88072b3b577
--- /dev/null
+++ b/test/datatype/opal_datatype_bigcount.c
@@ -0,0 +1,219 @@
+/* -*- Mode: C; c-basic-offset:4 ; -*- */
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/**
+ * OPAL-layer "big count" datatype tests.
+ *
+ * This is a singleton test (no MPI_Init, OPAL library only) that
+ * exercises the parts of the big-count datatype support that live in
+ * OPAL:
+ *
+ *   1. The count/displacement type-punning helpers in
+ *      opal/util/count_disp_array.h.  An opal_count_array_t aliases
+ *      either an int[] (32 bits per element) or a size_t[] (64 bits
+ *      per element); the disp variant aliases int[] or ptrdiff_t[].
+ *      These tests verify that values larger than INT_MAX survive a
+ *      store/read-back through the 64-bit-backed flavor, and that the
+ *      32-bit-backed flavor is reported correctly.
+ *
+ *   2. The OPAL datatype engine's 64-bit size/extent accounting: a
+ *      contiguous type whose element count exceeds INT_MAX must report
+ *      the correct (64-bit) size and extent rather than a truncated
+ *      32-bit value.
+ *
+ * These paths are not otherwise covered by the test/datatype suite.
+ */
+
+#include "opal_config.h"
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "opal/datatype/opal_datatype.h"
+#include "opal/runtime/opal.h"
+#include "opal/util/count_disp_array.h"
+
+static int failures = 0;
+
+#define CHECK(cond)                                                       \
+    do {                                                                  \
+        if (!(cond)) {                                                    \
+            fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__,       \
+                    #cond);                                               \
+            ++failures;                                                   \
+        }                                                                 \
+    } while (0)
+
+/* True only where size_t is wide enough for the 64-bit count path to be
+ * meaningful (and therefore where opal_count_array_is_64bit() can be
+ * true).  On a 32-bit size_t platform big count is not supported, so the
+ * 64-bit-specific assertions are skipped. */
+static bool have_64bit_counts(void)
+{
+    return 8 == sizeof(size_t);
+}
+
+static void test_count_array_punning(void)
+{
+    /* 32-bit-backed: int[] with values up to INT_MAX. */
+    int idata[3] = {0, 7, INT_MAX};
+    opal_count_array_t ia = OPAL_COUNT_ARRAY_CREATE(idata);
+
+    CHECK(!opal_count_array_is_64bit(ia));
+    CHECK(sizeof(int) == opal_count_array_sizeof(ia));
+    CHECK((size_t) 0 == opal_count_array_get(ia, 0));
+    CHECK((size_t) 7 == opal_count_array_get(ia, 1));
+    CHECK((size_t) INT_MAX == opal_count_array_get(ia, 2));
+
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipping 64-bit count assertions)\n");
+        return;
+    }
+
+    /* 64-bit-backed: size_t[] holding values above INT_MAX.  This is the
+     * heart of big count: the value must round-trip undamaged. */
+    size_t big1 = (size_t) INT_MAX + 1;
+    size_t big2 = (size_t) INT_MAX * 4 + 123;
+    size_t sdata[3] = {1, big1, big2};
+    opal_count_array_t sa = OPAL_COUNT_ARRAY_CREATE(sdata);
+
+    CHECK(opal_count_array_is_64bit(sa));
+    CHECK(sizeof(size_t) == opal_count_array_sizeof(sa));
+    CHECK((size_t) 1 == opal_count_array_get(sa, 0));
+    CHECK(big1 == opal_count_array_get(sa, 1));
+    CHECK(big2 == opal_count_array_get(sa, 2));
+
+    /* Write-back of an above-INT_MAX value. */
+    size_t big3 = (size_t) INT_MAX * 7 + 5;
+    opal_count_array_set(sa, 0, big3);
+    CHECK(big3 == opal_count_array_get(sa, 0));
+    /* Untouched neighbors stay intact. */
+    CHECK(big1 == opal_count_array_get(sa, 1));
+    CHECK(big2 == opal_count_array_get(sa, 2));
+}
+
+static void test_disp_array_punning(void)
+{
+    /* 32-bit-backed: int[] displacements. */
+    int idata[2] = {-3, INT_MAX};
+    opal_disp_array_t ia = OPAL_DISP_ARRAY_CREATE(idata);
+
+    CHECK(!opal_disp_array_is_64bit(ia));
+    CHECK(sizeof(int) == opal_disp_array_sizeof(ia));
+    CHECK((ptrdiff_t) -3 == opal_disp_array_get(ia, 0));
+    CHECK((ptrdiff_t) INT_MAX == opal_disp_array_get(ia, 1));
+
+    if (!have_64bit_counts()) {
+        return;
+    }
+
+    /* 64-bit-backed: ptrdiff_t[] displacements above INT_MAX, including a
+     * large negative one. */
+    ptrdiff_t big_pos = (ptrdiff_t) INT_MAX * 5 + 9;
+    ptrdiff_t big_neg = -((ptrdiff_t) INT_MAX * 5 + 9);
+    ptrdiff_t pdata[2] = {big_pos, big_neg};
+    opal_disp_array_t pa = OPAL_DISP_ARRAY_CREATE(pdata);
+
+    CHECK(opal_disp_array_is_64bit(pa));
+    CHECK(sizeof(ptrdiff_t) == opal_disp_array_sizeof(pa));
+    CHECK(big_pos == opal_disp_array_get(pa, 0));
+    CHECK(big_neg == opal_disp_array_get(pa, 1));
+
+    /* Write-back of a large negative displacement; neighbor stays intact. */
+    ptrdiff_t big3 = -((ptrdiff_t) INT_MAX * 7 + 5);
+    opal_disp_array_set(pa, 0, big3);
+    CHECK(big3 == opal_disp_array_get(pa, 0));
+    CHECK(big_neg == opal_disp_array_get(pa, 1));
+}
+
+static void test_engine_large_contiguous(void)
+{
+    /* The whole function builds types whose size/extent exceed INT_MAX, so it
+     * is only meaningful (and only well-defined) where size_t/ptrdiff_t are
+     * 64-bit.  Guard up front -- otherwise the very first contiguous below
+     * overflows ptrdiff_t on a 32-bit platform. */
+    if (!have_64bit_counts()) {
+        printf("  (32-bit size_t: skipped)\n");
+        return;
+    }
+
+    /* A contiguous run of (INT_MAX + 1000) single bytes: an int would
+     * overflow, so size/extent must be computed in 64 bits.  Note this
+     * only allocates O(1) datatype *metadata* -- no large buffer. */
+    size_t count = (size_t) INT_MAX + 1000;
+    opal_datatype_t *pdt = opal_datatype_create(2);
+    CHECK(NULL != pdt);
+    if (NULL == pdt) {
+        return;
+    }
+
+    int rc = opal_datatype_add(pdt, &opal_datatype_uint1, count, 0, 1);
+    CHECK(0 == rc);
+    opal_datatype_commit(pdt);
+
+    size_t size = 0;
+    opal_datatype_type_size(pdt, &size);
+    CHECK(count == size);
+
+    ptrdiff_t extent = 0;
+    opal_datatype_type_extent(pdt, &extent);
+    CHECK((ptrdiff_t) count == extent);
+
+    printf("  contiguous(%" PRIuPTR " x uint1): size=%" PRIuPTR
+           " extent=%td\n",
+           (uintptr_t) count, (uintptr_t) size, extent);
+
+    opal_datatype_destroy(&pdt);
+
+    /* Push past 4 GB to make truncation unmistakable. */
+    size_t bigger = (size_t) INT_MAX * 3; /* ~6.4 GB */
+    opal_datatype_t *pdt2 = opal_datatype_create(2);
+    CHECK(NULL != pdt2);
+    if (NULL == pdt2) {
+        return;
+    }
+    rc = opal_datatype_add(pdt2, &opal_datatype_uint1, bigger, 0, 1);
+    CHECK(0 == rc);
+    opal_datatype_commit(pdt2);
+    size = 0;
+    opal_datatype_type_size(pdt2, &size);
+    CHECK(bigger == size);
+    extent = 0;
+    opal_datatype_type_extent(pdt2, &extent);
+    CHECK((ptrdiff_t) bigger == extent);
+    opal_datatype_destroy(&pdt2);
+}
+
+int main(int argc, char *argv[])
+{
+    opal_init(&argc, &argv);
+
+    printf("--- opal_count_array punning ---\n");
+    test_count_array_punning();
+    printf("--- opal_disp_array punning ---\n");
+    test_disp_array_punning();
+    printf("--- opal datatype engine (size/extent > INT_MAX) ---\n");
+    test_engine_large_contiguous();
+
+    opal_finalize();
+
+    if (0 == failures) {
+        printf("SUCCESS: all OPAL big-count datatype checks passed\n");
+        return 0;
+    }
+    fprintf(stderr, "FAILURE: %d OPAL big-count datatype check(s) failed\n",
+            failures);
+    return 1;
+}
diff --git a/test/datatype/opal_datatype_test.c b/test/datatype/opal_datatype_test.c
index 06f3dd12695..bc30d4bb377 100644
--- a/test/datatype/opal_datatype_test.c
+++ b/test/datatype/opal_datatype_test.c
@@ -805,7 +805,7 @@ int main(int argc, char *argv[])
     assert(pdt2 == NULL);
 
     /* clean-ups all data allocations */
-    opal_finalize_util();
+    opal_finalize();
 
     return OPAL_SUCCESS;
 }
diff --git a/test/datatype/opal_ddt_api.c b/test/datatype/opal_ddt_api.c
new file mode 100644
index 00000000000..45eb50a38ab
--- /dev/null
+++ b/test/datatype/opal_ddt_api.c
@@ -0,0 +1,668 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for OPAL datatype API functions with little or no existing
+ * coverage:
+ *
+ *   opal_datatype_is_monotonic          (opal_datatype_monotonic.c)
+ *   opal_datatype_get_element_count     (opal_datatype_get_count.c)
+ *   opal_datatype_set_element_count     (opal_datatype_get_count.c)
+ *   opal_datatype_compute_ptypes        (opal_datatype_get_count.c)
+ *   opal_datatype_copy_content_same_ddt (opal_datatype_copy.c)
+ *   opal_datatype_clone                 (opal_datatype_clone.c)
+ *   opal_datatype_resize                (opal_datatype_resize.c)
+ *
+ * Plus helpers exercising opal_datatype_create / opal_datatype_add /
+ * opal_datatype_commit used to build the non-trivial types above.
+ *
+ * NOTE: The library is built with -DNDEBUG, so assert() is a no-op.
+ * All verification MUST go through test_verify() / test_failure().
+ *
+ * NOTE ON INIT: The task specification suggests opal_init_util(), but
+ * opal_datatype_init() (and the convertor / accelerator framework that
+ * opal_datatype_is_monotonic() requires) is only bootstrapped by the
+ * full opal_init() path.  Every sibling datatype test (ddt_pack.c,
+ * checksum.c, opal_datatype_test.c, …) confirms this.  We therefore
+ * call opal_init(&argc, &argv) / opal_finalize() following the
+ * established codebase pattern.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/datatype/opal_datatype.h"
+#include "opal/datatype/opal_datatype_internal.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------------------------------------------------------ */
+/* Helper: build a vector of (count) blocks of (blocklen) elements of
+ * base_type, with inter-block stride (stride * sizeof(base_type)).
+ * The caller is responsible for OBJ_RELEASE on the returned pointer.
+ */
+static opal_datatype_t *make_vector(const opal_datatype_t *base_type,
+                                    int count, int blocklen, int stride)
+{
+    opal_datatype_t *pdt;
+    ptrdiff_t extent;
+
+    opal_datatype_type_extent(base_type, &extent);
+    pdt = opal_datatype_create(base_type->desc.used + 2);
+    if (NULL == pdt) {
+        return NULL;
+    }
+
+    if ((blocklen == stride) || (1 == count)) {
+        /* contiguous */
+        opal_datatype_add(pdt, base_type, (size_t)(count * blocklen), 0, extent);
+    } else if (1 == blocklen) {
+        opal_datatype_add(pdt, base_type, (size_t) count, 0, extent * stride);
+    } else {
+        opal_datatype_t *inner;
+        inner = opal_datatype_create(base_type->desc.used + 2);
+        if (NULL == inner) {
+            OBJ_RELEASE(pdt);
+            return NULL;
+        }
+        opal_datatype_add(inner, base_type, (size_t) blocklen, 0, extent);
+        opal_datatype_add(pdt, inner, (size_t) count, 0, extent * stride);
+        OBJ_RELEASE(inner);
+    }
+
+    opal_datatype_commit(pdt);
+    return pdt;
+}
+
+/* ------------------------------------------------------------------ */
+/* test_is_monotonic
+ *
+ * Definitions:
+ *   A contiguous array of int4 is trivially monotonic.
+ *   A vector with positive stride (stride > blocklen) is monotonic:
+ *     consecutive iov bases advance forward in memory.
+ *   A type whose iov stream walks backward (decreasing base addresses)
+ *   is NOT monotonic.
+ *
+ * Primary non-monotonic construction — negative-stride vector:
+ *   3 single int4 elements, stride = -2 (i.e. each element is placed
+ *   2*sizeof(int4) = 8 bytes BEFORE the previous one).
+ *   opal_datatype_add(pdt, &int4, count=3, disp=0, extent=-8)
+ *   Layout:  elem[0] @ 0, elem[1] @ -8, elem[2] @ -16
+ *   The convertor produces iov_base = 0, then -8, then -16 — strictly
+ *   decreasing → not monotonic.
+ *   This uses the blocklen==1 path in make_vector, which issues a
+ *   single opal_datatype_add with extent*stride.  A single loop cannot
+ *   be reordered by the commit-time optimizer, so the backward traversal
+ *   order is guaranteed by construction.
+ *
+ * Secondary non-monotonic construction (redundant cross-check) —
+ * reversed-displacement struct:
+ *   add int4 @ disp=4 first, then add int4 @ disp=0.
+ *   MPI struct semantics require descriptors to be traversed in the
+ *   order they were added, so the convertor visits offset 4 before
+ *   offset 0 — backward.  We verify true_ub==8 before trusting the
+ *   monotonicity result to confirm commit did not reorder descriptors.
+ */
+static void test_is_monotonic(void)
+{
+    opal_datatype_t *pdt_contig;
+    opal_datatype_t *pdt_pos_vector;
+    opal_datatype_t *pdt_neg_stride;
+    opal_datatype_t *pdt_backward_struct;
+    int32_t result;
+
+    /* --- contiguous int4 array: monotonic --- */
+    pdt_contig = opal_datatype_create(opal_datatype_int4.desc.used + 2);
+    test_verify("create contiguous type", NULL != pdt_contig);
+    if (NULL != pdt_contig) {
+        opal_datatype_add(pdt_contig, &opal_datatype_int4,
+                          4, 0, (ptrdiff_t) sizeof(int32_t));
+        opal_datatype_commit(pdt_contig);
+
+        result = opal_datatype_is_monotonic(pdt_contig);
+        test_verify("contiguous int4 array is monotonic (result == 1)",
+                    1 == result);
+        OBJ_RELEASE(pdt_contig);
+    }
+
+    /* --- vector with positive stride: monotonic --- */
+    /* 3 blocks of 2 int4, stride 5 (gap between blocks). */
+    pdt_pos_vector = make_vector(&opal_datatype_int4, 3, 2, 5);
+    test_verify("create positive-stride vector", NULL != pdt_pos_vector);
+    if (NULL != pdt_pos_vector) {
+        result = opal_datatype_is_monotonic(pdt_pos_vector);
+        test_verify("positive-stride vector is monotonic (result == 1)",
+                    1 == result);
+        OBJ_RELEASE(pdt_pos_vector);
+    }
+
+    /* --- Primary non-monotonic: negative-stride vector --- */
+    /* 3 single int4 elements, extent per step = -2 * sizeof(int4) = -8.
+     * Layout: elem[0] @ 0, elem[1] @ -8, elem[2] @ -16.
+     * A single opal_datatype_add loop cannot be reordered by commit,
+     * so the backward traversal is guaranteed.
+     * Sanity: true_lb == -16, true_ub == 4 (first element's ub).
+     */
+    {
+        ptrdiff_t e = (ptrdiff_t) sizeof(int32_t); /* 4 */
+        pdt_neg_stride = opal_datatype_create(opal_datatype_int4.desc.used + 2);
+        test_verify("create negative-stride vector", NULL != pdt_neg_stride);
+        if (NULL != pdt_neg_stride) {
+            /* blocklen=1, stride=-2: extent_per_step = e * -2 = -8 */
+            opal_datatype_add(pdt_neg_stride, &opal_datatype_int4,
+                              3, 0, e * (-2));
+            opal_datatype_commit(pdt_neg_stride);
+
+            /* Confirm construction: true_lb=-16, true_ub=4 */
+            test_verify("neg-stride: true_lb == -16",
+                        -16 == (int) pdt_neg_stride->true_lb);
+            test_verify("neg-stride: true_ub == 4",
+                        4   == (int) pdt_neg_stride->true_ub);
+
+            result = opal_datatype_is_monotonic(pdt_neg_stride);
+            test_verify("negative-stride vector is NOT monotonic (result == 0)",
+                        0 == result);
+            OBJ_RELEASE(pdt_neg_stride);
+        }
+    }
+
+    /* --- Secondary non-monotonic: reversed-displacement struct --- */
+    /* add int4 @ disp=4 first, then add int4 @ disp=0.
+     * Verify construction (true_ub==8) before trusting the result.
+     */
+    {
+        ptrdiff_t e = (ptrdiff_t) sizeof(int32_t);
+        pdt_backward_struct = opal_datatype_create(4);
+        test_verify("create backward struct", NULL != pdt_backward_struct);
+        if (NULL != pdt_backward_struct) {
+            /* first descriptor: int4 at byte 4 */
+            opal_datatype_add(pdt_backward_struct, &opal_datatype_int4, 1, e, e);
+            /* second descriptor: int4 at byte 0  (lower address) */
+            opal_datatype_add(pdt_backward_struct, &opal_datatype_int4, 1, 0, e);
+            opal_datatype_commit(pdt_backward_struct);
+
+            /* Sanity: true extent covers bytes 0..7 */
+            test_verify("backward struct: true_lb == 0",
+                        0 == (int) pdt_backward_struct->true_lb);
+            test_verify("backward struct: true_ub == 8",
+                        8 == (int) pdt_backward_struct->true_ub);
+
+            result = opal_datatype_is_monotonic(pdt_backward_struct);
+            test_verify("backward struct is NOT monotonic (result == 0)",
+                        0 == result);
+            OBJ_RELEASE(pdt_backward_struct);
+        }
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* test_get_element_count
+ *
+ * Type: vector of 3 blocks x 4 elements of int4, stride = 6.
+ *   Basic element size = 4 bytes.
+ *   Total basic elements = 3 * 4 = 12.
+ *   type->size = 12 * 4 = 48 bytes.
+ *
+ * opal_datatype_get_element_count(t, t->size) must return 12.
+ * opal_datatype_get_element_count(t, 4)       must return 1.
+ * opal_datatype_get_element_count(t, 16)      must return 4.
+ */
+static void test_get_element_count(void)
+{
+    opal_datatype_t *pdt;
+    ssize_t count;
+    size_t sz;
+
+    /* 3 blocks * 4 int4 elements, stride 6 */
+    pdt = make_vector(&opal_datatype_int4, 3, 4, 6);
+    test_verify("create vector for get_element_count", NULL != pdt);
+    if (NULL == pdt) {
+        return;
+    }
+
+    /* Hand-computed: 3*4 = 12 elements, size = 12*4 = 48 */
+    opal_datatype_type_size(pdt, &sz);
+    test_verify("vector size == 48", 48 == (int) sz);
+
+    count = opal_datatype_get_element_count(pdt, sz);
+    test_verify("get_element_count(full size) == 12", 12 == (int) count);
+
+    count = opal_datatype_get_element_count(pdt, 4);
+    test_verify("get_element_count(4 bytes) == 1", 1 == (int) count);
+
+    count = opal_datatype_get_element_count(pdt, 16);
+    test_verify("get_element_count(16 bytes) == 4", 4 == (int) count);
+
+    OBJ_RELEASE(pdt);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_set_element_count
+ *
+ * Using the same vector (3 blocks x 4 int4, stride 6):
+ *   set_element_count(0, &len)  => len = 0
+ *   set_element_count(1, &len)  => len = 4   (1 * 4 bytes)
+ *   set_element_count(4, &len)  => len = 16  (4 * 4 bytes)
+ *   set_element_count(12, &len) => len = 48  (12 * 4 bytes = full type)
+ */
+static void test_set_element_count(void)
+{
+    opal_datatype_t *pdt;
+    size_t len;
+    int32_t rc;
+
+    pdt = make_vector(&opal_datatype_int4, 3, 4, 6);
+    test_verify("create vector for set_element_count", NULL != pdt);
+    if (NULL == pdt) {
+        return;
+    }
+
+    len = (size_t) -1;
+    rc = opal_datatype_set_element_count(pdt, 0, &len);
+    test_verify("set_element_count(0) returns 0", 0 == rc);
+    test_verify("set_element_count(0) => len == 0", 0 == (int) len);
+
+    len = (size_t) -1;
+    rc = opal_datatype_set_element_count(pdt, 1, &len);
+    test_verify("set_element_count(1) returns 0", 0 == rc);
+    test_verify("set_element_count(1) => len == 4", 4 == (int) len);
+
+    len = (size_t) -1;
+    rc = opal_datatype_set_element_count(pdt, 4, &len);
+    test_verify("set_element_count(4) returns 0", 0 == rc);
+    test_verify("set_element_count(4) => len == 16", 16 == (int) len);
+
+    len = (size_t) -1;
+    rc = opal_datatype_set_element_count(pdt, 12, &len);
+    test_verify("set_element_count(12) returns 0", 0 == rc);
+    test_verify("set_element_count(12) => len == 48", 48 == (int) len);
+
+    OBJ_RELEASE(pdt);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_compute_ptypes
+ *
+ * Type: struct of 1 int1 + 1 float8.
+ *   After commit and opal_datatype_compute_ptypes():
+ *     ptypes[OPAL_DATATYPE_INT1]   == 1
+ *     ptypes[OPAL_DATATYPE_FLOAT8] == 1
+ *   All other ptypes entries == 0.
+ *   type->size == sizeof(int8) + sizeof(float8) == 1 + 8 == 9 bytes.
+ *   type->nbElems == 2 (one int1 + one float8 == 2 basic elements).
+ */
+static void test_compute_ptypes(void)
+{
+    opal_datatype_t *pdt;
+    size_t sz;
+    int rc;
+
+    /* Build { int1 @ disp=0, float8 @ disp=1 } */
+    pdt = opal_datatype_create((ssize_t)(opal_datatype_int1.desc.used
+                                        + opal_datatype_float8.desc.used + 4));
+    test_verify("create struct type for compute_ptypes", NULL != pdt);
+    if (NULL == pdt) {
+        return;
+    }
+
+    opal_datatype_add(pdt, &opal_datatype_int1, 1, 0,
+                      (ptrdiff_t) sizeof(int8_t));
+    opal_datatype_add(pdt, &opal_datatype_float8, 1, 1,
+                      (ptrdiff_t) sizeof(double));
+    opal_datatype_commit(pdt);
+
+    opal_datatype_type_size(pdt, &sz);
+    /* size = 1 (int1) + 8 (float8) = 9 */
+    test_verify("struct int1+float8 size == 9", 9 == (int) sz);
+    test_verify("struct int1+float8 nbElems == 2", 2 == (int) pdt->nbElems);
+
+    rc = opal_datatype_compute_ptypes(pdt);
+    test_verify("compute_ptypes returns 0", 0 == rc);
+    test_verify("ptypes array allocated", NULL != pdt->ptypes);
+
+    if (NULL != pdt->ptypes) {
+        test_verify("ptypes[OPAL_DATATYPE_INT1] == 1",
+                    1 == (int) pdt->ptypes[OPAL_DATATYPE_INT1]);
+        test_verify("ptypes[OPAL_DATATYPE_FLOAT8] == 1",
+                    1 == (int) pdt->ptypes[OPAL_DATATYPE_FLOAT8]);
+        /* A type containing only int1+float8 must NOT count int4 */
+        test_verify("ptypes[OPAL_DATATYPE_INT4] == 0",
+                    0 == (int) pdt->ptypes[OPAL_DATATYPE_INT4]);
+        /* second call must be a no-op (array already allocated) */
+        rc = opal_datatype_compute_ptypes(pdt);
+        test_verify("second compute_ptypes call returns 0 (no-op)", 0 == rc);
+    }
+
+    OBJ_RELEASE(pdt);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_copy_content_same_ddt
+ *
+ * Type: vector of 3 blocks x 2 int4 elements, stride = 4.
+ *   extent    = stride * sizeof(int4) = 4 * 4 = 16 bytes
+ *   size      = 3 * 2 * 4 = 24 bytes (only data bytes, no gaps)
+ *   true_ub   = 3*stride*4 - gap_at_end = (3-1)*16 + 2*4 = 40 bytes
+ *   Memory span for 1 repetition = 40 bytes (true_extent).
+ *
+ * Layout (byte offsets, stride=4 int4 = 16 bytes per block):
+ *   block 0: bytes  0.. 7  (2 x int4)
+ *   block 1: bytes 16..23
+ *   block 2: bytes 32..39
+ *   gap bytes: 8..15, 24..31  (each 8 bytes)
+ *
+ * We allocate two 40-byte buffers, fill src with ascending bytes,
+ * fill dst with sentinel (0xCC), then call copy_content_same_ddt.
+ * Verify:
+ *   (a) data bytes (blocks) in dst match src.
+ *   (b) gap bytes in dst still hold the sentinel (gaps not touched).
+ */
+static void test_copy_content_same_ddt(void)
+{
+    opal_datatype_t *pdt;
+    ptrdiff_t lb, extent;
+    size_t sz;
+    int rc;
+
+    /* 3 blocks x 2 int4, stride 4 int4 = 4 * sizeof(int4) */
+    pdt = make_vector(&opal_datatype_int4, 3, 2, 4);
+    test_verify("create vector for copy_content", NULL != pdt);
+    if (NULL == pdt) {
+        return;
+    }
+
+    opal_datatype_get_extent(pdt, &lb, &extent);
+    opal_datatype_type_size(pdt, &sz);
+
+    /* extent = 3 blocks * 4 stride * 4 bytes = wait, let's think again.
+     *
+     * stride = 4 elements of int4 = stride in units of basic type.
+     * make_vector uses: opal_datatype_add(inner, base, count=2, 0, e)
+     *                   opal_datatype_add(outer, inner, count=3, 0, e*stride=4*4=16)
+     * So outer extent = 3 * 16 = 48 bytes.  But wait: outer ub = 0 + 2*16 + 2*4 = 40.
+     * Actually: extent = ub - lb.
+     *
+     * After commit:
+     *   lb = 0
+     *   ub = (count-1)*stride*e + blocklen*e = 2*16 + 2*4 = 40
+     *   extent = 40
+     *   size = 3*2*4 = 24
+     *
+     * Buffer size needed for 1 repetition = true_extent = ub - lb = 40.
+     */
+    {
+        ptrdiff_t true_lb, true_extent;
+        size_t buf_size;
+        unsigned char *src_buf, *dst_buf;
+        unsigned int i;
+
+        opal_datatype_get_true_extent(pdt, &true_lb, &true_extent);
+        buf_size = (size_t)(true_lb + true_extent);
+        if (0 == buf_size) {
+            test_failure("copy_content: unexpected zero buffer size");
+            OBJ_RELEASE(pdt);
+            return;
+        }
+
+        src_buf = (unsigned char *) malloc(buf_size);
+        dst_buf = (unsigned char *) malloc(buf_size);
+        test_verify("alloc src_buf for copy_content", NULL != src_buf);
+        test_verify("alloc dst_buf for copy_content", NULL != dst_buf);
+        if (NULL == src_buf || NULL == dst_buf) {
+            free(src_buf);
+            free(dst_buf);
+            OBJ_RELEASE(pdt);
+            return;
+        }
+
+        /* Fill src with ascending pattern, dst with sentinel */
+        for (i = 0; i < (unsigned int) buf_size; i++) {
+            src_buf[i] = (unsigned char)(i & 0xFF);
+        }
+        memset(dst_buf, 0xCC, buf_size);
+
+        /* pdst / psrc adjusted by lb (== 0 here, so same as buf ptr) */
+        rc = opal_datatype_copy_content_same_ddt(pdt, 1,
+                                                 (char *)(dst_buf - lb),
+                                                 (char *)(src_buf - lb));
+        test_verify("copy_content_same_ddt returns OPAL_SUCCESS",
+                    OPAL_SUCCESS == rc);
+
+        /*
+         * Verify data blocks were copied correctly.
+         * Block layout (stride=4 int4=16, blocklen=2 int4=8):
+         *   block 0: bytes  0.. 7
+         *   block 1: bytes 16..23
+         *   block 2: bytes 32..39
+         */
+        {
+            int all_data_ok = 1;
+            int all_gaps_ok = 1;
+            int b, byte_off;
+            int block_size_bytes = 2 * (int) sizeof(int32_t);  /* 8 */
+            int stride_bytes     = 4 * (int) sizeof(int32_t);  /* 16 */
+
+            for (b = 0; b < 3; b++) {
+                int block_start = b * stride_bytes;
+
+                /* data bytes inside the block */
+                for (i = (unsigned int) block_start;
+                     i < (unsigned int)(block_start + block_size_bytes);
+                     i++) {
+                    if (dst_buf[i] != src_buf[i]) {
+                        all_data_ok = 0;
+                    }
+                }
+                /* gap bytes after this block (skip for last block) */
+                if (b < 2) {
+                    int gap_start = block_start + block_size_bytes;
+                    int gap_end   = block_start + stride_bytes;
+                    for (byte_off = gap_start; byte_off < gap_end; byte_off++) {
+                        if (0xCC != dst_buf[byte_off]) {
+                            all_gaps_ok = 0;
+                        }
+                    }
+                }
+            }
+
+            test_verify("copy_content: data bytes match src", all_data_ok);
+            test_verify("copy_content: gap bytes retain sentinel (0xCC)",
+                        all_gaps_ok);
+        }
+
+        free(src_buf);
+        free(dst_buf);
+    }
+
+    /* Suppress unused-variable warnings for lb/extent/sz. */
+    (void) lb;
+    (void) extent;
+    (void) sz;
+
+    OBJ_RELEASE(pdt);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_clone
+ *
+ * Build a committed vector, clone it into a freshly created
+ * destination, then verify:
+ *   (a) size matches
+ *   (b) extent matches
+ *   (c) nbElems matches
+ *   (d) flags (committed bit) match
+ *
+ * The destination datatype must be allocated with enough descriptor
+ * space before clone is called -- mirroring ompi_datatype_duplicate().
+ */
+static void test_clone(void)
+{
+    opal_datatype_t *orig;
+    opal_datatype_t *cloned;
+    size_t orig_sz, clone_sz;
+    ptrdiff_t orig_ext, clone_ext;
+
+    /* original: 4 blocks x 3 float8, stride 5 */
+    orig = make_vector(&opal_datatype_float8, 4, 3, 5);
+    test_verify("create vector for clone test", NULL != orig);
+    if (NULL == orig) {
+        return;
+    }
+
+    /* Allocate clone destination with enough descriptor room */
+    cloned = opal_datatype_create((ssize_t)(orig->desc.used + 2));
+    test_verify("create clone destination", NULL != cloned);
+    if (NULL == cloned) {
+        OBJ_RELEASE(orig);
+        return;
+    }
+
+    int32_t rc = opal_datatype_clone(orig, cloned);
+    test_verify("opal_datatype_clone returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    opal_datatype_type_size(orig,   &orig_sz);
+    opal_datatype_type_size(cloned, &clone_sz);
+    test_verify("clone size == original size", orig_sz == clone_sz);
+
+    opal_datatype_type_extent(orig,   &orig_ext);
+    opal_datatype_type_extent(cloned, &clone_ext);
+    test_verify("clone extent == original extent", orig_ext == clone_ext);
+
+    test_verify("clone nbElems == original nbElems",
+                orig->nbElems == cloned->nbElems);
+    test_verify("clone has COMMITTED flag",
+                opal_datatype_is_committed(cloned));
+
+    /* Hand-computed values for 4 blocks x 3 float8, stride 5:
+     *   size    = 4 * 3 * 8 = 96 bytes
+     *   extent  = (4-1)*5*8 + 3*8 = 120 + 24 = 144 bytes
+     *   nbElems = 4 * 3 = 12
+     */
+    test_verify("clone size == 96",    96  == (int) clone_sz);
+    test_verify("clone extent == 144", 144 == (int) clone_ext);
+    test_verify("clone nbElems == 12", 12  == (int) cloned->nbElems);
+
+    OBJ_RELEASE(cloned);
+    OBJ_RELEASE(orig);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_resize
+ *
+ * Build a committed vector of 2 blocks x 2 int4, stride 3.
+ *   natural size   = 2 * 2 * 4 = 16 bytes
+ *   natural extent = (2-1)*3*4 + 2*4 = 12 + 8 = 20 bytes
+ *   natural lb     = 0
+ *
+ * After resize(lb=0, extent=100):
+ *   lb     == 0
+ *   ub     == 100
+ *   extent == 100
+ *   size unchanged (resize only changes lb/ub, not actual data size)
+ *
+ * After resize(lb=-4, extent=100):
+ *   lb     == -4
+ *   ub     == -4 + 100 == 96
+ *   extent == 100
+ */
+static void test_resize(void)
+{
+    opal_datatype_t *pdt;
+    ptrdiff_t lb, ext;
+    size_t sz;
+    int32_t rc;
+
+    /* 2 blocks x 2 int4, stride 3 */
+    pdt = make_vector(&opal_datatype_int4, 2, 2, 3);
+    test_verify("create vector for resize test", NULL != pdt);
+    if (NULL == pdt) {
+        return;
+    }
+
+    /* Verify natural state before resize */
+    opal_datatype_type_size(pdt, &sz);
+    test_verify("resize: natural size == 16", 16 == (int) sz);
+
+    opal_datatype_get_extent(pdt, &lb, &ext);
+    test_verify("resize: natural lb == 0", 0 == (int) lb);
+    test_verify("resize: natural extent == 20", 20 == (int) ext);
+
+    /* resize to extent=100, lb=0 */
+    rc = opal_datatype_resize(pdt, 0, 100);
+    test_verify("opal_datatype_resize(lb=0, ext=100) returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+
+    opal_datatype_get_extent(pdt, &lb, &ext);
+    test_verify("after resize(0,100): lb == 0",   0   == (int) lb);
+    test_verify("after resize(0,100): ext == 100", 100 == (int) ext);
+
+    /* size must be unchanged by resize */
+    opal_datatype_type_size(pdt, &sz);
+    test_verify("resize does not change size (still 16)", 16 == (int) sz);
+
+    /* resize with negative lb */
+    rc = opal_datatype_resize(pdt, -4, 100);
+    test_verify("opal_datatype_resize(lb=-4, ext=100) returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+
+    opal_datatype_get_extent(pdt, &lb, &ext);
+    test_verify("after resize(-4,100): lb == -4",  -4  == (int) lb);
+    test_verify("after resize(-4,100): ext == 100", 100 == (int) ext);
+
+    opal_datatype_type_lb(pdt, &lb);
+    test_verify("type_lb after resize(-4,100) == -4", -4 == (int) lb);
+
+    opal_datatype_type_ub(pdt, &ext);
+    test_verify("type_ub after resize(-4,100) == 96", 96 == (int) ext);
+
+    OBJ_RELEASE(pdt);
+}
+
+/* ------------------------------------------------------------------ */
+int main(int argc, char *argv[])
+{
+    int r;
+
+    test_init("opal_ddt_api");
+
+    /* Full opal_init required: opal_datatype_init() and the accelerator
+     * framework (needed by opal_datatype_is_monotonic()) are bootstrapped
+     * only by opal_init(), not by the lighter opal_init_util().  All
+     * sibling tests in test/datatype/ follow the same pattern.        */
+    opal_init(&argc, &argv);
+
+    test_is_monotonic();
+    test_get_element_count();
+    test_set_element_count();
+    test_compute_ptypes();
+    test_copy_content_same_ddt();
+    test_clone();
+    test_resize();
+
+    r = test_finalize();
+    opal_finalize();
+    return r;
+}
diff --git a/test/datatype/opal_ddt_hetero.c b/test/datatype/opal_ddt_hetero.c
new file mode 100644
index 00000000000..0c83972b2f0
--- /dev/null
+++ b/test/datatype/opal_ddt_hetero.c
@@ -0,0 +1,840 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Self-checking unit tests for OPAL heterogeneous datatype conversion.
+ *
+ * Covered source files:
+ *   opal/datatype/opal_copy_functions_heterogeneous.c  -- byte-swap copy functions
+ *   opal/datatype/opal_datatype_fake_stack.c           -- position-restore stack
+ *   opal/datatype/opal_datatype_get_count.c            -- compute_remote_size / compute_ptypes
+ *
+ * Strategy: construct a "remote" architecture whose endianness is the
+ * opposite of the local one (remote_arch = opal_local_arch ^ OPAL_ARCH_ISBIGENDIAN).
+ * Build wire buffers by byte-reversing known host values independently of
+ * the implementation, then unpack via a heterogeneous convertor and assert
+ * that the recovered host values match.
+ *
+ * NOTE: The library is compiled with -DNDEBUG so assert() is a no-op.
+ * All verification MUST go through test_verify() so that failures are real.
+ *
+ * Initialization note: this file uses opal_init()/opal_finalize() rather
+ * than the opal_init_util()+opal_datatype_init() pattern used by some OPAL
+ * class tests.  The reason is that opal_convertor_prepare_for_recv()
+ * unconditionally invokes opal_convertor_accelerator_init(), which calls into
+ * the accelerator framework.  That framework is only initialized by the full
+ * opal_init() path (see the explicit ordering note in opal_init.c: "datatype
+ * convertor code has a dependency on the accelerator framework being
+ * initialized").  This matches unpack_hetero.c and every other in-tree
+ * datatype test that links against only libopal.la.
+ */
+
+/*
+ * STATUS: this test is intentionally NOT wired into test/datatype/Makefile.am
+ * (not built or run by "make check") because two of its assertions currently
+ * fail and document open items awaiting a maintainer's decision:
+ *
+ *   1. test_fake_stack_direct() (the "fake_stack: bConverted advanced to
+ *      seek_to" assertion) exercises an internal helper
+ *      (opal_convertor_create_stack_with_pos_general) that has zero production
+ *      callers; the asserted postcondition is undocumented and does not hold
+ *      for the predefined-contiguous input used here.  Likely a test bug.
+ *
+ *   2. test_set_position_and_resume() (the "set_pos: elem[2] correct after
+ *      resume" assertion) reveals a real disp-composition asymmetry between the
+ *      homogeneous and heterogeneous unpack paths after a mid-stream
+ *      opal_convertor_set_position() on a FLAG_CONTIGUOUS recv convertor.
+ *      Whether that is a live bug depends on whether production ever drives
+ *      that exact combination -- a question for a datatype maintainer.
+ *
+ * The remaining ~60 assertions pass on both Linux and macOS.  See the inline
+ * NOTE/OPEN QUESTION comments at each failing assertion for the full analysis.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/datatype/opal_convertor.h"
+#include "opal/datatype/opal_datatype.h"
+#include "opal/datatype/opal_datatype_internal.h"
+#include "opal/datatype/opal_datatype_prototypes.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+#include "opal/util/arch.h"
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* -----------------------------------------------------------------------
+ * Helper: portable byte-reversal.
+ * Produces the byte-swapped representation of 'in' in 'out'.
+ * 'size' is the width in bytes (1, 2, 4, 8, ...).
+ * This is derived from first principles (mirror the byte array), NOT from
+ * opal_dt_swap_bytes, so that the test is independent of the implementation.
+ * ----------------------------------------------------------------------- */
+static void swap_bytes(void *out, const void *in, size_t size)
+{
+    const unsigned char *src = (const unsigned char *) in;
+    unsigned char *dst = (unsigned char *) out;
+    size_t i;
+
+    for (i = 0; i < size; i++) {
+        dst[i] = src[size - 1 - i];
+    }
+}
+
+/* -----------------------------------------------------------------------
+ * Helper: unpack one or more elements of a predefined type from a
+ * wire buffer via a heterogeneous convertor and return the convertor.
+ * The caller must OBJ_RELEASE the returned convertor.
+ * Returns OPAL_SUCCESS on success, otherwise the error code.
+ * ----------------------------------------------------------------------- */
+static int hetero_unpack(uint32_t remote_arch,
+                         const opal_datatype_t *dtype,
+                         size_t count,
+                         void *recv_buf,
+                         void *wire_buf,
+                         size_t wire_len)
+{
+    opal_convertor_t *conv;
+    struct iovec iov;
+    uint32_t iov_count;
+    size_t max_data;
+    int rc;
+
+    conv = opal_convertor_create(remote_arch, 0);
+    if (NULL == conv) {
+        return OPAL_ERR_OUT_OF_RESOURCE;
+    }
+
+    rc = opal_convertor_prepare_for_recv(conv, dtype, count, recv_buf);
+    if (OPAL_SUCCESS != rc) {
+        OBJ_RELEASE(conv);
+        return rc;
+    }
+
+    iov.iov_base = wire_buf;
+    iov.iov_len  = wire_len;
+    iov_count    = 1;
+    max_data     = wire_len;
+    opal_convertor_unpack(conv, &iov, &iov_count, &max_data);
+
+    OBJ_RELEASE(conv);
+    return OPAL_SUCCESS;
+}
+
+/* -----------------------------------------------------------------------
+ * Test sections
+ * ----------------------------------------------------------------------- */
+
+/*
+ * test_int2: copy_int2_heterogeneous
+ *
+ * Single int16_t value.  The wire buffer contains the byte-swapped
+ * representation; unpacking through a hetero convertor must restore
+ * the original host value.
+ */
+static void test_int2(uint32_t remote_arch)
+{
+    int16_t host_val = 0x1234;
+    int16_t wire_val;
+    int16_t recv_val = 0;
+    int rc;
+
+    /* Build wire buffer: byte-reversed host value */
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_int2, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("int2: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("int2: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_int4: copy_int4_heterogeneous
+ *
+ * Single int32_t.  This is the same path exercised by unpack_hetero.c
+ * but with a known value and a real assertion.
+ */
+static void test_int4(uint32_t remote_arch)
+{
+    int32_t host_val = 0x01020304;
+    int32_t wire_val;
+    int32_t recv_val = 0;
+    int rc;
+
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_int4, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("int4: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("int4: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_int8: copy_int8_heterogeneous
+ */
+static void test_int8(uint32_t remote_arch)
+{
+    int64_t host_val = (int64_t) 0x0102030405060708LL;
+    int64_t wire_val;
+    int64_t recv_val = 0;
+    int rc;
+
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_int8, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("int8: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("int8: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_uint2: copy_int2_heterogeneous (reused for UINT2)
+ */
+static void test_uint2(uint32_t remote_arch)
+{
+    uint16_t host_val = 0xABCD;
+    uint16_t wire_val;
+    uint16_t recv_val = 0;
+    int rc;
+
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_uint2, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("uint2: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("uint2: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_uint4: copy_int4_heterogeneous (reused for UINT4)
+ */
+static void test_uint4(uint32_t remote_arch)
+{
+    uint32_t host_val = 0xDEADBEEFU;
+    uint32_t wire_val;
+    uint32_t recv_val = 0;
+    int rc;
+
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_uint4, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("uint4: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("uint4: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_uint8: copy_int8_heterogeneous (reused for UINT8)
+ */
+static void test_uint8(uint32_t remote_arch)
+{
+    uint64_t host_val = 0xCAFEBABEDEADF00DULL;
+    uint64_t wire_val;
+    uint64_t recv_val = 0;
+    int rc;
+
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_uint8, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("uint8: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("uint8: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_float4: copy_float4_heterogeneous
+ *
+ * IEEE-754 single precision.  Use the bit-pattern of a known float.
+ * 1.0f in IEEE-754 LE = 0x3F800000.
+ * Byte-reversed: 0x0000803F.
+ * After unpacking via hetero convertor we should recover 1.0f.
+ */
+static void test_float4(uint32_t remote_arch)
+{
+    float host_val = 1.0f;
+    float wire_val_f;
+    float recv_val = 0.0f;
+    int rc;
+
+    swap_bytes(&wire_val_f, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_float4, 1, &recv_val,
+                       &wire_val_f, sizeof(wire_val_f));
+    test_verify("float4: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("float4: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_float8: copy_float8_heterogeneous
+ *
+ * IEEE-754 double precision.  Use 1.0 = 0x3FF0000000000000 in LE.
+ */
+static void test_float8(uint32_t remote_arch)
+{
+    double host_val = 1.0;
+    double wire_val_d;
+    double recv_val = 0.0;
+    int rc;
+
+    swap_bytes(&wire_val_d, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_float8, 1, &recv_val,
+                       &wire_val_d, sizeof(wire_val_d));
+    test_verify("float8: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("float8: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_int4_contiguous_array
+ *
+ * Unpack 4 contiguous int32_t values.  This exercises the
+ * multi-element contiguous path in copy_int4_heterogeneous (the
+ * "countperblock = count, nblocksleft = 1" branch).
+ */
+static void test_int4_contiguous_array(uint32_t remote_arch)
+{
+    static const int32_t host_vals[4] = {0x10203040, 0x50607080,
+                                         (int32_t) 0x90A0B0C0, (int32_t) 0xD0E0F001};
+    int32_t wire_buf[4];
+    int32_t recv_buf[4];
+    size_t i;
+    int rc;
+
+    memset(recv_buf, 0, sizeof(recv_buf));
+
+    for (i = 0; i < 4; i++) {
+        swap_bytes(&wire_buf[i], &host_vals[i], sizeof(int32_t));
+    }
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_int4, 4, recv_buf,
+                       wire_buf, sizeof(wire_buf));
+    test_verify("int4[4]: unpack succeeds", OPAL_SUCCESS == rc);
+    for (i = 0; i < 4; i++) {
+        test_verify("int4[4]: each element byte-swapped correctly",
+                    host_vals[i] == recv_buf[i]);
+    }
+}
+
+/*
+ * test_int4_negative: single negative int32_t
+ *
+ * Verify sign extension is preserved across the byte swap.
+ */
+static void test_int4_negative(uint32_t remote_arch)
+{
+    int32_t host_val = -1;          /* 0xFFFFFFFF */
+    int32_t wire_val;
+    int32_t recv_val = 0;
+    int rc;
+
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_int4, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("int4 negative: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("int4 negative: -1 round-trips correctly", -1 == recv_val);
+}
+
+/*
+ * test_wchar: copy_wchar_heterogeneous
+ *
+ * wchar_t width is platform-dependent; we only test if sizeof(wchar_t) > 1
+ * so there is something to swap.
+ */
+static void test_wchar(uint32_t remote_arch)
+{
+    wchar_t host_val;
+    wchar_t wire_val;
+    wchar_t recv_val;
+    int rc;
+
+    if (sizeof(wchar_t) <= 1) {
+        /* Nothing interesting to byte-swap; skip but count as a pass. */
+        test_verify("wchar: skip (sizeof == 1)", 1);
+        return;
+    }
+
+    host_val = (wchar_t) 0x0410;       /* some non-ASCII codepoint, fits in 2+ byte wchar_t */
+    swap_bytes(&wire_val, &host_val, sizeof(host_val));
+    recv_val = 0;
+
+    rc = hetero_unpack(remote_arch, &opal_datatype_wchar, 1, &recv_val,
+                       &wire_val, sizeof(wire_val));
+    test_verify("wchar: unpack succeeds", OPAL_SUCCESS == rc);
+    test_verify("wchar: byte-swap round-trip", host_val == recv_val);
+}
+
+/*
+ * test_remote_size_predefined
+ *
+ * opal_convertor_compute_remote_size on a predefined type should return
+ * count * sizeof(type).
+ *
+ * Covers: opal_datatype_compute_remote_size (predefined short-circuit path)
+ */
+static void test_remote_size_predefined(uint32_t remote_arch)
+{
+    opal_convertor_t *conv;
+    size_t rsize;
+    const size_t count = 3;
+    int64_t dummy_buf[3] = {0, 0, 0};
+    int rc;
+
+    conv = opal_convertor_create(remote_arch, 0);
+    test_verify("remote_size pred: convertor created", NULL != conv);
+    if (NULL == conv) {
+        return;
+    }
+
+    rc = opal_convertor_prepare_for_recv(conv, &opal_datatype_int8, count, dummy_buf);
+    test_verify("remote_size pred: prepare ok", OPAL_SUCCESS == rc);
+
+    rsize = opal_convertor_compute_remote_size(conv);
+    test_verify("remote_size pred: returns count * sizeof(int8)",
+                (count * sizeof(int64_t)) == rsize);
+
+    OBJ_RELEASE(conv);
+}
+
+/*
+ * test_remote_size_derived
+ *
+ * opal_convertor_compute_remote_size on a derived type must call
+ * opal_datatype_compute_ptypes (get_count.c).
+ *
+ * We build a struct-like derived type: 3 x int4 followed by 2 x int8.
+ * Local and remote sizes of each predefined type are the same in this
+ * test (we only flip endianness, not type sizes), so remote_size should
+ * equal local_size = count * (3*4 + 2*8) = 1 * 20 = 20 bytes.
+ *
+ * Covers: opal_datatype_compute_ptypes, opal_datatype_compute_remote_size
+ *         (derived type path)
+ */
+static void test_remote_size_derived(uint32_t remote_arch)
+{
+    opal_datatype_t *derived = NULL;
+    opal_convertor_t *conv   = NULL;
+    static char dummy_recv[64];
+    size_t rsize;
+    int rc;
+    /* 3 x int4 (12 bytes) + 2 x int8 (16 bytes) = 28 bytes total */
+    const size_t expected_local = 3 * sizeof(int32_t) + 2 * sizeof(int64_t);
+
+    rc = opal_datatype_create_contiguous(0, &opal_datatype_empty, &derived);
+    test_verify("remote_size derived: create empty ok", OPAL_SUCCESS == rc);
+    if (OPAL_SUCCESS != rc || NULL == derived) {
+        return;
+    }
+
+    rc = opal_datatype_add(derived, &opal_datatype_int4, 3, 0, sizeof(int32_t));
+    test_verify("remote_size derived: add int4 ok", OPAL_SUCCESS == rc);
+
+    rc = opal_datatype_add(derived, &opal_datatype_int8, 2,
+                           3 * (ptrdiff_t) sizeof(int32_t), sizeof(int64_t));
+    test_verify("remote_size derived: add int8 ok", OPAL_SUCCESS == rc);
+
+    rc = opal_datatype_commit(derived);
+    test_verify("remote_size derived: commit ok", OPAL_SUCCESS == rc);
+
+    conv = opal_convertor_create(remote_arch, 0);
+    test_verify("remote_size derived: convertor created", NULL != conv);
+    if (NULL == conv) {
+        opal_datatype_destroy(&derived);
+        return;
+    }
+
+    /* Use the dummy recv buffer (not accessed; we only test size computation). */
+    rc = opal_convertor_prepare_for_recv(conv, derived, 1, dummy_recv);
+    test_verify("remote_size derived: prepare ok", OPAL_SUCCESS == rc);
+
+    rsize = opal_convertor_compute_remote_size(conv);
+    /*
+     * Since we only flip endianness (not type sizes), the remote size equals
+     * the local size for this derived type.
+     */
+    test_verify("remote_size derived: equals expected local size",
+                expected_local == rsize);
+
+    OBJ_RELEASE(conv);
+    opal_datatype_destroy(&derived);
+}
+
+/*
+ * test_strided_int4_unpack
+ *
+ * Build a derived type with two non-contiguous int32_t fields (a "struct"
+ * with a gap).  This exercises copy_int4_heterogeneous on a non-contiguous
+ * layout (the "countperblock=1, nblocksleft=count" branch).
+ *
+ * Layout per instance (bytes):
+ *   [0..3]  = field A (int32_t)
+ *   [4..7]  = gap (unwritten)
+ *   [8..11] = field B (int32_t)
+ *   extent  = 12 bytes
+ *   size    = 8 bytes
+ *
+ * The wire buffer for N instances is N*8 bytes of packed (gapless) data.
+ * The recv buffer must be at least N*12 bytes.
+ */
+static void test_strided_int4_unpack(uint32_t remote_arch)
+{
+    opal_datatype_t *gapped = NULL;
+    opal_convertor_t *conv  = NULL;
+    const int NINSTANCES = 3;
+    /*
+     * Two int32_t fields per instance, separated by a 4-byte gap.
+     * field A at offset 0, field B at offset 8.
+     * extent = 12 bytes.
+     */
+    const ptrdiff_t disp_A  = 0;
+    const ptrdiff_t disp_B  = 8;
+    const ptrdiff_t ext_instance = 12; /* extent of one instance */
+
+    /* Host values: 3 instances, 2 fields each */
+    static const int32_t host_A[3] = {0x11223344, 0x55667788, (int32_t) 0x99AABBCC};
+    static const int32_t host_B[3] = {0x0A0B0C0D, 0x0E0F1011, 0x12131415};
+
+    /* Wire buffer: packed, 2 int32 per instance, no gaps */
+    int32_t wire_buf[6];
+    /* Recv buffer: 3 instances each of extent 12 bytes = 9 int32 slots */
+    int32_t recv_buf[9];
+    struct iovec iov;
+    uint32_t iov_count;
+    size_t max_data;
+    int rc;
+    int i;
+
+    memset(recv_buf, 0xAB, sizeof(recv_buf)); /* fill with sentinel */
+
+    /* Build wire buffer: byte-swapped A then byte-swapped B, per instance */
+    for (i = 0; i < NINSTANCES; i++) {
+        swap_bytes(&wire_buf[i * 2 + 0], &host_A[i], sizeof(int32_t));
+        swap_bytes(&wire_buf[i * 2 + 1], &host_B[i], sizeof(int32_t));
+    }
+
+    /* Create derived type: empty base, then add field A and field B */
+    rc = opal_datatype_create_contiguous(0, &opal_datatype_empty, &gapped);
+    test_verify("gapped int4: create empty ok", OPAL_SUCCESS == rc);
+    if (OPAL_SUCCESS != rc || NULL == gapped) {
+        return;
+    }
+
+    /* field A: 1 int4 at offset 0, extent = disp_B (= 8) */
+    rc = opal_datatype_add(gapped, &opal_datatype_int4, 1, disp_A, disp_B);
+    test_verify("gapped int4: add field A ok", OPAL_SUCCESS == rc);
+
+    /* field B: 1 int4 at offset 8, extent = ext_instance (= 12) */
+    rc = opal_datatype_add(gapped, &opal_datatype_int4, 1, disp_B, ext_instance);
+    test_verify("gapped int4: add field B ok", OPAL_SUCCESS == rc);
+
+    rc = opal_datatype_commit(gapped);
+    test_verify("gapped int4: commit ok", OPAL_SUCCESS == rc);
+
+    test_verify("gapped int4: type size == 8",
+                (size_t) 8 == gapped->size);
+    test_verify("gapped int4: type is non-contiguous",
+                0 == (gapped->flags & OPAL_DATATYPE_FLAG_NO_GAPS));
+
+    conv = opal_convertor_create(remote_arch, 0);
+    test_verify("gapped int4: convertor created", NULL != conv);
+    if (NULL == conv) {
+        opal_datatype_destroy(&gapped);
+        return;
+    }
+
+    rc = opal_convertor_prepare_for_recv(conv, gapped, NINSTANCES, recv_buf);
+    test_verify("gapped int4: prepare ok", OPAL_SUCCESS == rc);
+
+    iov.iov_base = wire_buf;
+    iov.iov_len  = sizeof(wire_buf);    /* 6 * 4 = 24 bytes */
+    iov_count    = 1;
+    max_data     = sizeof(wire_buf);
+    opal_convertor_unpack(conv, &iov, &iov_count, &max_data);
+
+    /*
+     * Each instance of gapped occupies ext_instance=12 bytes in recv_buf
+     * (i.e. 3 int32 slots).  Field A is at offset 0, field B at offset 8
+     * within each instance.
+     *
+     *  instance i recv_buf layout (int32 indices):
+     *    [i*3 + 0] = field A    (offset 0 / ext=12 => byte 0 in instance)
+     *    [i*3 + 1] = gap        (bytes 4-7, never written)
+     *    [i*3 + 2] = field B    (offset 8 / ext=12 => byte 8 in instance)
+     */
+    for (i = 0; i < NINSTANCES; i++) {
+        test_verify("gapped int4: field A round-trips",
+                    host_A[i] == recv_buf[i * 3 + 0]);
+        test_verify("gapped int4: field B round-trips",
+                    host_B[i] == recv_buf[i * 3 + 2]);
+    }
+
+    OBJ_RELEASE(conv);
+    opal_datatype_destroy(&gapped);
+}
+
+/*
+ * test_fake_stack_direct
+ *
+ * Directly call opal_convertor_create_stack_with_pos_general to exercise
+ * the heterogeneous position-restore stack (opal_datatype_fake_stack.c).
+ *
+ * The function signature is:
+ *   int opal_convertor_create_stack_with_pos_general(
+ *           opal_convertor_t *pConvertor,
+ *           size_t starting_point,
+ *           const size_t *sizes);
+ *
+ * Preconditions from the source:
+ *   - starting_point != 0
+ *   - pConvertor->bConverted != starting_point  (i.e. not already there)
+ *   - starting_point <= pConvertor->count * pData->size
+ *   - !(pConvertor->flags & CONVERTOR_SEND)
+ *
+ * We set up a heterogeneous recv convertor over an array of int4 values,
+ * partially unpack the first element (so bConverted = sizeof(int32_t)),
+ * then call the function to seek to the second element.  After the call
+ * we verify that bConverted has advanced to the requested position.
+ *
+ * Note: opal_convertor_create_stack_with_pos_general is declared in
+ * opal_datatype_fake_stack.c with an extern prototype inside the same
+ * file.  We declare it here to be able to call it.
+ */
+extern int opal_convertor_create_stack_with_pos_general(opal_convertor_t *pConvertor,
+                                                        size_t starting_point,
+                                                        const size_t *sizes);
+
+static void test_fake_stack_direct(uint32_t remote_arch)
+{
+    /*
+     * 4 int32_t values; after seeking past 2 elements, bConverted == 8.
+     */
+    static const int32_t host_vals[4] = {10, 20, 30, 40};
+    int32_t wire_buf[4];
+    int32_t recv_buf[4];
+    opal_convertor_t *conv = NULL;
+    struct iovec iov;
+    uint32_t iov_count;
+    size_t max_data;
+    size_t seek_to;
+    int rc;
+    int i;
+
+    memset(recv_buf, 0, sizeof(recv_buf));
+
+    for (i = 0; i < 4; i++) {
+        swap_bytes(&wire_buf[i], &host_vals[i], sizeof(int32_t));
+    }
+
+    conv = opal_convertor_create(remote_arch, 0);
+    test_verify("fake_stack: convertor created", NULL != conv);
+    if (NULL == conv) {
+        return;
+    }
+
+    rc = opal_convertor_prepare_for_recv(conv, &opal_datatype_int4, 4, recv_buf);
+    test_verify("fake_stack: prepare ok", OPAL_SUCCESS == rc);
+
+    /* Unpack the first element so that bConverted = sizeof(int32_t) */
+    iov.iov_base = wire_buf;
+    iov.iov_len  = sizeof(int32_t);
+    iov_count    = 1;
+    max_data     = sizeof(int32_t);
+    opal_convertor_unpack(conv, &iov, &iov_count, &max_data);
+
+    test_verify("fake_stack: first element unpacked",
+                host_vals[0] == recv_buf[0]);
+    test_verify("fake_stack: bConverted == sizeof(int32_t) after first unpack",
+                sizeof(int32_t) == conv->bConverted);
+
+    /*
+     * Now seek to just past the second element: starting_point = 2*4 = 8.
+     * Preconditions satisfied:
+     *   starting_point (8) != 0
+     *   bConverted (4) != starting_point (8)
+     *   starting_point (8) <= count*size (4*4 = 16)
+     *   !(flags & CONVERTOR_SEND)
+     */
+    seek_to = 2 * sizeof(int32_t);
+    rc = opal_convertor_create_stack_with_pos_general(conv, seek_to,
+                                                      opal_datatype_local_sizes);
+    test_verify("fake_stack: create_stack_with_pos_general returns ok",
+                OPAL_SUCCESS == rc);
+    /*
+     * NOTE: this assertion currently FAILS, and the assertion -- not the
+     * library -- is the suspect.  opal_convertor_create_stack_with_pos_general()
+     * is an internal helper with ZERO production callers (grep the tree): for a
+     * predefined CONTIGUOUS datatype like int4, production always routes through
+     * opal_convertor_create_stack_with_pos_contig() instead, so this path is
+     * never exercised in practice.  Called directly here in the heterogeneous +
+     * predefined-contiguous regime, the general walker consumes the single DATA
+     * descriptor element and falls through to bConverted = local_size (16), not
+     * the asserted seek_to (8).  There is no documented postcondition that
+     * bConverted == starting_point for this helper.  Left in place (failing) for
+     * a maintainer to confirm/restrict.  (This test is intentionally NOT wired
+     * into "make check"; see the file-level note.)
+     */
+    test_verify("fake_stack: bConverted advanced to seek_to",
+                seek_to == conv->bConverted);
+
+    OBJ_RELEASE(conv);
+}
+
+/*
+ * test_set_position_and_resume
+ *
+ * Exercises the convertor set-position path (which internally calls
+ * opal_convertor_set_position_nocheck) then resumes unpacking.
+ *
+ * We send 4 int32_t values one at a time, verifying that we can seek
+ * to an arbitrary byte offset mid-array and continue unpacking from
+ * that point.
+ *
+ * This path also exercises the fake_stack indirectly via
+ * opal_convertor_set_position -> set_position_nocheck ->
+ * (for contiguous types) create_stack_with_pos_contig.
+ */
+static void test_set_position_and_resume(uint32_t remote_arch)
+{
+    static const int32_t host_vals[4] = {100, 200, 300, 400};
+    int32_t wire_buf[4];
+    int32_t recv_buf[4];
+    opal_convertor_t *conv = NULL;
+    struct iovec iov;
+    uint32_t iov_count;
+    size_t max_data;
+    size_t pos;
+    int rc;
+    int i;
+
+    memset(recv_buf, 0, sizeof(recv_buf));
+    for (i = 0; i < 4; i++) {
+        swap_bytes(&wire_buf[i], &host_vals[i], sizeof(int32_t));
+    }
+
+    conv = opal_convertor_create(remote_arch, 0);
+    test_verify("set_pos: convertor created", NULL != conv);
+    if (NULL == conv) {
+        return;
+    }
+
+    rc = opal_convertor_prepare_for_recv(conv, &opal_datatype_int4, 4, recv_buf);
+    test_verify("set_pos: prepare ok", OPAL_SUCCESS == rc);
+
+    /* Unpack element 0 only */
+    iov.iov_base = &wire_buf[0];
+    iov.iov_len  = sizeof(int32_t);
+    iov_count    = 1;
+    max_data     = sizeof(int32_t);
+    opal_convertor_unpack(conv, &iov, &iov_count, &max_data);
+    test_verify("set_pos: elem[0] correct", host_vals[0] == recv_buf[0]);
+
+    /* Seek past element 1 (skip it) to byte offset 8 */
+    pos = 2 * sizeof(int32_t);
+    rc = opal_convertor_set_position(conv, &pos);
+    test_verify("set_pos: set_position ok", OPAL_SUCCESS == rc);
+    test_verify("set_pos: position landed at 8", (size_t) 8 == conv->bConverted);
+
+    /* Unpack elements 2 and 3 from their respective wire positions */
+    iov.iov_base = &wire_buf[2];
+    iov.iov_len  = 2 * sizeof(int32_t);
+    iov_count    = 1;
+    max_data     = 2 * sizeof(int32_t);
+    opal_convertor_unpack(conv, &iov, &iov_count, &max_data);
+    /*
+     * OPEN QUESTION (this assertion currently FAILS): after set_position(8) on a
+     * HETEROGENEOUS, FLAG_CONTIGUOUS recv convertor, elem[2] is never written
+     * (stays 0) while elem[3] resumes correctly.  Traced cause: a disp-
+     * composition mismatch -- opal_convertor_create_stack_with_pos_contig()
+     * encodes the element skip in stack[0].disp, but the heterogeneous unpack
+     * path (opal_unpack_general) initializes conv_ptr from stack[1].disp (== 0).
+     * The identical sequence PASSES homogeneous (the contig unpack composes both
+     * disps) and FAILS heterogeneous.  Whether this is a live OPAL bug or merely
+     * an unreachable path depends on whether production ever calls
+     * opal_convertor_set_position() mid-stream on a heterogeneous +
+     * FLAG_CONTIGUOUS recv convertor -- a question for a maintainer.  Left in
+     * place (failing).  (This test is intentionally NOT wired into "make check";
+     * see the file-level note.)
+     */
+    test_verify("set_pos: elem[2] correct after resume", host_vals[2] == recv_buf[2]);
+    test_verify("set_pos: elem[3] correct after resume", host_vals[3] == recv_buf[3]);
+
+    OBJ_RELEASE(conv);
+}
+
+/* -----------------------------------------------------------------------
+ * main
+ * ----------------------------------------------------------------------- */
+int main(int argc, char *argv[])
+{
+    uint32_t remote_arch;
+    int ret;
+
+    test_init("opal_ddt_hetero");
+
+    /*
+     * opal_init initialises the arch detection (opal_local_arch) and
+     * the datatype engine.  All existing OPAL-only datatype tests follow
+     * this pattern.
+     */
+    opal_init(NULL, NULL);
+
+    /*
+     * Simulate a peer whose endianness is the opposite of ours.
+     * This forces every conversion function to byte-swap.
+     */
+    remote_arch = opal_local_arch ^ OPAL_ARCH_ISBIGENDIAN;
+
+    /* --- copy_functions_heterogeneous.c --- */
+    test_int2(remote_arch);
+    test_int4(remote_arch);
+    test_int8(remote_arch);
+    test_uint2(remote_arch);
+    test_uint4(remote_arch);
+    test_uint8(remote_arch);
+    test_float4(remote_arch);
+    test_float8(remote_arch);
+    test_wchar(remote_arch);
+
+    /* Contiguous multi-element: exercises "countperblock = count" branch */
+    test_int4_contiguous_array(remote_arch);
+    test_int4_negative(remote_arch);
+
+    /* --- opal_datatype_get_count.c (compute_ptypes, compute_remote_size) --- */
+    test_remote_size_predefined(remote_arch);
+    test_remote_size_derived(remote_arch);
+
+    /* --- non-contiguous strided type --- */
+    test_strided_int4_unpack(remote_arch);
+
+    /* --- opal_datatype_fake_stack.c --- */
+    test_fake_stack_direct(remote_arch);
+
+    /* --- set_position path (also drives fake_stack indirectly) --- */
+    test_set_position_and_resume(remote_arch);
+
+    ret = test_finalize();
+    opal_finalize();
+    return ret;
+}
diff --git a/test/monitoring/Makefile.am b/test/monitoring/Makefile.am
deleted file mode 100644
index ed7b257d8e7..00000000000
--- a/test/monitoring/Makefile.am
+++ /dev/null
@@ -1,49 +0,0 @@
-#
-# Copyright (c) 2013-2017 The University of Tennessee and The University
-#                         of Tennessee Research Foundation.  All rights
-#                         reserved.
-# Copyright (c) 2013-2017 Inria.  All rights reserved.
-# Copyright (c) 2015-2017 Research Organization for Information Science
-#                         and Technology (RIST). All rights reserved.
-# Copyright (c) 2016      IBM Corporation.  All rights reserved.
-# Copyright (c) 2016      Cisco Systems, Inc.  All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-# This test requires multiple processes to run. Don't run it as part
-# of 'make check'
-if PROJECT_OMPI
-    noinst_PROGRAMS = monitoring_test test_pvar_access test_overhead check_monitoring example_reduce_count
-    monitoring_test_SOURCES = monitoring_test.c
-    monitoring_test_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-    monitoring_test_LDADD = \
-        $(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-    test_pvar_access_SOURCES = test_pvar_access.c
-    test_pvar_access_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-    test_pvar_access_LDADD = \
-	$(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-    test_overhead_SOURCES = test_overhead.c
-    test_overhead_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-    test_overhead_LDADD = \
-	$(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-    check_monitoring_SOURCES = check_monitoring.c
-    check_monitoring_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-    check_monitoring_LDADD = \
-	$(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-    example_reduce_count_SOURCES = example_reduce_count.c
-    example_reduce_count_LDFLAGS = $(OMPI_PKG_CONFIG_LDFLAGS)
-    example_reduce_count_LDADD = \
-	$(top_builddir)/ompi/lib@OMPI_LIBMPI_NAME@.la \
-	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la
-endif # PROJECT_OMPI
-
-distclean-local:
-	rm -rf *.dSYM .deps .libs *.la *.lo monitoring_test test_pvar_access test_overhead check_monitoring example_reduce_count prof *.log *.o *.trs Makefile
diff --git a/test/mpi/Makefile.am b/test/mpi/Makefile.am
deleted file mode 100644
index 0c365ffeaf9..00000000000
--- a/test/mpi/Makefile.am
+++ /dev/null
@@ -1,20 +0,0 @@
-# -*- makefile -*-
-#
-# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
-#                         University Research and Technology
-#                         Corporation.  All rights reserved.
-# Copyright (c) 2004-2005 The University of Tennessee and The University
-#                         of Tennessee Research Foundation.  All rights
-#                         reserved.
-# Copyright (c) 2004-2009 High Performance Computing Center Stuttgart,
-#                         University of Stuttgart.  All rights reserved.
-# Copyright (c) 2004-2005 The Regents of the University of California.
-#                         All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-SUBDIRS = environment
diff --git a/test/mpi/environment/Makefile.am b/test/mpi/environment/Makefile.am
deleted file mode 100644
index 820856a3d51..00000000000
--- a/test/mpi/environment/Makefile.am
+++ /dev/null
@@ -1,33 +0,0 @@
-# -*- makefile -*-
-#
-# Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
-#                         University Research and Technology
-#                         Corporation.  All rights reserved.
-# Copyright (c) 2004-2005 The University of Tennessee and The University
-#                         of Tennessee Research Foundation.  All rights
-#                         reserved.
-# Copyright (c) 2004-2009 High Performance Computing Center Stuttgart,
-#                         University of Stuttgart.  All rights reserved.
-# Copyright (c) 2004-2005 The Regents of the University of California.
-#                         All rights reserved.
-# Copyright (c) 2016      IBM Corporation.  All rights reserved.
-# $COPYRIGHT$
-#
-# Additional copyrights may follow
-#
-# $HEADER$
-#
-
-AM_LDFLAGS = -lpthread
-
-noinst_PROGRAMS = chello
-
-chello_SOURCES = chello.c
-chello_LDADD = \
-	$(top_builddir)/src/lib@OMPI_LIBMPI_NAME@.la \
-	$(top_builddir)/src/libompi.la
-chello_DEPENDENCIES = $(chello_LDADD)
-
-
-distclean-local:
-	rm -rf *.dSYM .deps *.log *.o *.trs $(noinst_PROGRAMS) Makefile
diff --git a/test/mpi/environment/chello.c b/test/mpi/environment/chello.c
deleted file mode 100644
index 6f436673b3e..00000000000
--- a/test/mpi/environment/chello.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/* -*- C -*-
- *
- * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
- *                         University Research and Technology
- *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
- *                         of Tennessee Research Foundation.  All rights
- *                         reserved.
- * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
- *                         University of Stuttgart.  All rights reserved.
- * Copyright (c) 2004-2005 The Regents of the University of California.
- *                         All rights reserved.
- * $COPYRIGHT$
- *
- * Additional copyrights may follow
- *
- * $HEADER$
- *
- * The most basic of MPI applications
- */
-
-#include <mpi.h>
-#include <stdio.h>
-
-int main(int argc, char *argv[])
-{
-    MPI_Init(&argc, &argv);
-
-    printf("Hello, World\n");
-
-    MPI_Finalize();
-
-    return 0;
-}
diff --git a/test/mpi/environment/run_tests b/test/mpi/environment/run_tests
deleted file mode 100755
index 25d8818ba79..00000000000
--- a/test/mpi/environment/run_tests
+++ /dev/null
@@ -1,55 +0,0 @@
-#! /bin/csh -f
-#  Name
-#  ====
-#  run script for mpi environment tests
-
-# Arguments
-# ==========
-#
-# test_list  =  no args or all runs all tests
-#              or
-#               chello runs the chello environment test
-
-# Usage
-#
-# =====
-# To invoke this script, enter either
-#     run_tests
-# with no arguments to run all tests, or
-#     run_tests <test_name>
-
-umask 007
-
-if  ("x$1" == "x") then
-  echo "do all - no args"
-  ./chello
-else
-  foreach target ($argv)
-    switch ($target)
-    case "all":
-      ./chello
-      breaksw
-    case "chello":
-      ./$target
-      breaksw
-    case "help"
-      echo "correct use: "
-      echo "    run_tests help (this message)"
-      echo "    run_tests all   (to run all mpi environment tests)"
-      echo "or  run_tests with any combination of the following: "
-      echo  "       <chello>"
-      break
-    default
-      echo "There is no program <$target> to run"
-      echo "correct use: "
-      echo "    run_tests help (this message)"
-      echo "    run_tests all   (to run all mpi environment tests)"
-      echo "or  run_tests with any combination of the following: "
-      echo  "       <chello>"
-      break
-    endsw
-  end
-
-endif
-
-
diff --git a/test/mpi/run_tests b/test/mpi/run_tests
deleted file mode 100755
index 73b5c80516f..00000000000
--- a/test/mpi/run_tests
+++ /dev/null
@@ -1,56 +0,0 @@
-#! /bin/csh -f
-#  Name
-#  ====
-#  run script for mpi tests
-
-# Arguments
-# ==========
-#
-# test_list  =  no args or all runs all tests
-#              or
-#               llm runs ompi mpi llm tests
-#               ns runs ompi mpi ns tests
-#               oob runs ompi mpi oob tests
-#               pcm runs ompi mpi pcm tests
-
-# Usage
-#
-# =====
-# To invoke this script, enter either
-#     run_tests
-# with no arguments to run all tests, or
-#     run_tests <test_name>
-
-umask 007
-
-if ("x$1" == "x") then
-  cd environment; ./run_tests all; cd ..;
-else
-
-  foreach target ($argv)
-    switch ($target)
-    case "all":
-      cd ../environment; ./run_tests all; cd ..;
-      breaksw
-    case "environment":
-      cd $target
-      ./run_tests;
-      cd ..;
-      breaksw
-    case "help":      echo "correct use: "
-      echo "    run_tests help (this message)"
-      echo "    run_tests all  (to run all mpi tests)"
-      echo "or  run_tests <llm | ns | oob | pcm>"
-      breaksw
-    default
-      echo "There is no part of mpia tests called program <$target> to run"
-      echo "correct use: "
-      echo "    run_tests all   (to run all mpi tests)"
-      echo "or  run_tests <environment>"
-      break
-    endsw
-  end
-
-endif
-
-
diff --git a/test/simple/Makefile b/test/simple/Makefile
index 5c763f878be..7da40424c85 100644
--- a/test/simple/Makefile
+++ b/test/simple/Makefile
@@ -4,8 +4,9 @@ PROGS = mpi_no_op mpi_barrier hello hello_nodename abort multi_abort comm_abort
 		crisscross read_write ziatest slave reduce-hang ziaprobe ziatest bcast_loop \
 		parallel_w8 parallel_w64 parallel_r8 parallel_r64 sio sendrecv_blaster early_abort \
 		debugger singleton_client_server intercomm_create spawn_tree init-exit77 mpi_info \
-		info_spawn server client ring binding badcoll attach xlib \
-		no-disconnect nonzero interlib pinterlib add_host
+		info_spawn server client ring binding badcoll attach xlib ompio_file_info \
+		no-disconnect nonzero interlib pinterlib add_host \
+		buffer_attach_detach_f08
 
 all: $(PROGS)
 
@@ -23,6 +24,11 @@ xlib: xlib.c
 pinterlib: pinterlib.c
 	$(CC) $(CFLAGS) $(CFLAGS_INTERNAL) $^ -o $@ -lpmix
 
+# Fortran mpi_f08 test (no built-in .f90 rule)
+
+buffer_attach_detach_f08: buffer_attach_detach_f08.f90
+	$(FC) $(FCFLAGS) $^ -o $@
+
 CC = mpicc
 CFLAGS = -g --openmpi:linkall
 CFLAGS_INTERNAL = -I../../.. -I../../../orte/include -I../../../opal/include
diff --git a/test/simple/buffer_attach_detach_f08.f90 b/test/simple/buffer_attach_detach_f08.f90
new file mode 100644
index 00000000000..521f6c5fb6b
--- /dev/null
+++ b/test/simple/buffer_attach_detach_f08.f90
@@ -0,0 +1,211 @@
+! -*- f90 -*-
+!
+! Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+! $COPYRIGHT$
+!
+! Additional copyrights may follow
+!
+! $HEADER$
+!
+! Regression test for the mpi_f08 buffer attach/detach bindings.
+!
+! This exercises MPI_Buffer_detach, MPI_Comm_detach_buffer, and
+! MPI_Session_detach_buffer (and their attach counterparts) and
+! verifies two things that the bindings previously got wrong:
+!
+! 1. detach must return, in the user's TYPE(C_PTR), the address of
+!    the buffer that was attached.  MPI_Buffer_detach used to pass
+!    &buffer to the back-end call, so the detached address was
+!    dropped into a local variable and the caller's C_PTR was never
+!    updated.
+!
+! 2. when an automatic buffer (MPI_BUFFER_AUTOMATIC) is detached, the
+!    binding must hand back the *Fortran* sentinel address, not the C
+!    library's internal sentinel ((void *) 4).  That requires the
+!    attach wrappers to translate the Fortran sentinel to the C
+!    sentinel (so the C library actually engages automatic mode) and
+!    the detach wrappers to translate the C sentinel back.
+!
+! Everything here is local (no communication), so the test runs fine
+! as a singleton:  ./buffer_attach_detach_f08
+!
+! Exits non-zero if any check fails.
+
+program buffer_attach_detach_f08
+    use, intrinsic :: iso_c_binding, only: c_ptr, c_loc, c_associated, &
+                                           c_null_ptr, c_intptr_t, c_int8_t
+    use mpi_f08
+    implicit none
+
+    integer, parameter :: BUFSIZE = 8192
+    ! The C sentinel MPI_BUFFER_AUTOMATIC is ((void *) 4); the Fortran
+    ! binding must never expose that value to Fortran code.
+    integer(c_intptr_t), parameter :: C_BUFFER_AUTOMATIC = 4_c_intptr_t
+
+    integer(c_int8_t), allocatable, target :: buf(:)
+    type(c_ptr) :: addr
+    integer :: isize, ierr, nerr
+    integer(c_intptr_t) :: ia_buf, ia_comm, ia_sess
+    type(MPI_Session) :: session
+
+    nerr = 0
+
+    call MPI_Init(ierr)
+    call must("MPI_Init", ierr)
+    ! Let the buffer calls report errors via ierr instead of aborting.
+    call MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN, ierr)
+    call must("MPI_Comm_set_errhandler", ierr)
+
+    allocate(buf(BUFSIZE))
+
+    ! ----------------------------------------------------------------
+    ! Normal-buffer round trips: detach must return the attached
+    ! address.  (This is the decisive check for the MPI_Buffer_detach
+    ! &buffer bug; the comm/session variants already returned the
+    ! address correctly and serve as regression guards.)
+    ! ----------------------------------------------------------------
+
+    addr = c_null_ptr
+    isize = -1
+    call MPI_Buffer_attach(buf, BUFSIZE, ierr)
+    call must("MPI_Buffer_attach", ierr)
+    call MPI_Buffer_detach(addr, isize, ierr)
+    call must("MPI_Buffer_detach", ierr)
+    call expect_addr("MPI_Buffer_detach returns attached address", &
+                     addr, c_loc(buf), nerr)
+    call expect_size("MPI_Buffer_detach returns attached size", &
+                     isize, BUFSIZE, nerr)
+
+    addr = c_null_ptr
+    isize = -1
+    call MPI_Comm_attach_buffer(MPI_COMM_SELF, buf, BUFSIZE, ierr)
+    call must("MPI_Comm_attach_buffer", ierr)
+    call MPI_Comm_detach_buffer(MPI_COMM_SELF, addr, isize, ierr)
+    call must("MPI_Comm_detach_buffer", ierr)
+    call expect_addr("MPI_Comm_detach_buffer returns attached address", &
+                     addr, c_loc(buf), nerr)
+    call expect_size("MPI_Comm_detach_buffer returns attached size", &
+                     isize, BUFSIZE, nerr)
+
+    call MPI_Session_init(MPI_INFO_NULL, MPI_ERRORS_RETURN, session, ierr)
+    call must("MPI_Session_init", ierr)
+
+    addr = c_null_ptr
+    isize = -1
+    call MPI_Session_attach_buffer(session, buf, BUFSIZE, ierr)
+    call must("MPI_Session_attach_buffer", ierr)
+    call MPI_Session_detach_buffer(session, addr, isize, ierr)
+    call must("MPI_Session_detach_buffer", ierr)
+    call expect_addr("MPI_Session_detach_buffer returns attached address", &
+                     addr, c_loc(buf), nerr)
+    call expect_size("MPI_Session_detach_buffer returns attached size", &
+                     isize, BUFSIZE, nerr)
+
+    ! ----------------------------------------------------------------
+    ! Automatic-buffer round trips: attach MPI_BUFFER_AUTOMATIC, then
+    ! detach.  The returned address must be the Fortran sentinel -- a
+    ! real, non-null address that is NOT the C sentinel (void *) 4 --
+    ! and must be identical across all three APIs.
+    ! ----------------------------------------------------------------
+
+    addr = c_null_ptr
+    call MPI_Buffer_attach(MPI_BUFFER_AUTOMATIC, BUFSIZE, ierr)
+    call must("MPI_Buffer_attach(AUTOMATIC)", ierr)
+    call MPI_Buffer_detach(addr, isize, ierr)
+    call must("MPI_Buffer_detach(AUTOMATIC)", ierr)
+    ia_buf = transfer(addr, ia_buf)
+    call expect_auto("MPI_Buffer_detach maps automatic sentinel", ia_buf, nerr)
+
+    addr = c_null_ptr
+    call MPI_Comm_attach_buffer(MPI_COMM_SELF, MPI_BUFFER_AUTOMATIC, BUFSIZE, ierr)
+    call must("MPI_Comm_attach_buffer(AUTOMATIC)", ierr)
+    call MPI_Comm_detach_buffer(MPI_COMM_SELF, addr, isize, ierr)
+    call must("MPI_Comm_detach_buffer(AUTOMATIC)", ierr)
+    ia_comm = transfer(addr, ia_comm)
+    call expect_auto("MPI_Comm_detach_buffer maps automatic sentinel", ia_comm, nerr)
+
+    addr = c_null_ptr
+    call MPI_Session_attach_buffer(session, MPI_BUFFER_AUTOMATIC, BUFSIZE, ierr)
+    call must("MPI_Session_attach_buffer(AUTOMATIC)", ierr)
+    call MPI_Session_detach_buffer(session, addr, isize, ierr)
+    call must("MPI_Session_detach_buffer(AUTOMATIC)", ierr)
+    ia_sess = transfer(addr, ia_sess)
+    call expect_auto("MPI_Session_detach_buffer maps automatic sentinel", ia_sess, nerr)
+
+    if (ia_buf == ia_comm .and. ia_buf == ia_sess) then
+        print '(a)', "PASS: automatic sentinel address consistent across APIs"
+    else
+        print '(a)', "FAIL: automatic sentinel address differs across APIs"
+        nerr = nerr + 1
+    end if
+
+    call MPI_Session_finalize(session, ierr)
+    call must("MPI_Session_finalize", ierr)
+
+    deallocate(buf)
+
+    if (nerr == 0) then
+        print '(a)', "All mpi_f08 buffer attach/detach tests PASSED"
+    else
+        print '(a,i0,a)', "TEST FAILED: ", nerr, " check(s) failed"
+    end if
+
+    call MPI_Finalize(ierr)
+
+    if (nerr /= 0) then
+        error stop 1
+    end if
+
+contains
+
+    ! Abort on an unexpected MPI error return.
+    subroutine must(label, ie)
+        character(len=*), intent(in) :: label
+        integer, intent(in) :: ie
+        if (ie /= MPI_SUCCESS) then
+            print '(3a,i0)', "ERROR: ", label, " failed, ierr=", ie
+            call MPI_Abort(MPI_COMM_WORLD, 1)
+        end if
+    end subroutine must
+
+    ! Check that a returned C_PTR matches the expected address.
+    subroutine expect_addr(label, got, want, ne)
+        character(len=*), intent(in) :: label
+        type(c_ptr), intent(in) :: got, want
+        integer, intent(inout) :: ne
+        if (c_associated(got, want)) then
+            print '(2a)', "PASS: ", label
+        else
+            print '(2a)', "FAIL: ", label
+            ne = ne + 1
+        end if
+    end subroutine expect_addr
+
+    ! Check that a detach returned the size that was attached.
+    subroutine expect_size(label, got, want, ne)
+        character(len=*), intent(in) :: label
+        integer, intent(in) :: got, want
+        integer, intent(inout) :: ne
+        if (got == want) then
+            print '(2a)', "PASS: ", label
+        else
+            print '(2a,i0)', "FAIL: ", label, got
+            ne = ne + 1
+        end if
+    end subroutine expect_size
+
+    ! Check that an automatic-detach result is the Fortran sentinel:
+    ! non-null, and not the C sentinel (void *) 4.
+    subroutine expect_auto(label, ia, ne)
+        character(len=*), intent(in) :: label
+        integer(c_intptr_t), intent(in) :: ia
+        integer, intent(inout) :: ne
+        if (ia /= 0_c_intptr_t .and. ia /= C_BUFFER_AUTOMATIC) then
+            print '(2a)', "PASS: ", label
+        else
+            print '(2a,i0)', "FAIL: ", label, ia
+            ne = ne + 1
+        end if
+    end subroutine expect_auto
+
+end program buffer_attach_detach_f08
diff --git a/test/simple/ompio_file_info.c b/test/simple/ompio_file_info.c
new file mode 100644
index 00000000000..8e068d1b4a2
--- /dev/null
+++ b/test/simple/ompio_file_info.c
@@ -0,0 +1,798 @@
+/*
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Manual invocation:
+ *
+ *   mpirun -n 2 --mca io ompio ./ompio_file_info
+ *
+ * The memory-allocation-kind checks request a supported kind in-process
+ * (see main()), so they run without the launcher having to forward the
+ * MCA parameter.
+ *
+ * Optional filesystem-specific checks:
+ *
+ *   OMPIO_FILE_INFO_LUSTRE_DIR=/mnt/lustre \
+ *       mpirun -n 2 --mca io ompio ./ompio_file_info
+ *   OMPIO_FILE_INFO_GPFS_DIR=/gpfs \
+ *       mpirun -n 2 --mca io ompio ./ompio_file_info
+ */
+
+#include "mpi.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static int errors = 0;
+
+enum {
+    SECTION_SKIPPED = 0,
+    SECTION_RAN = 1
+};
+
+static void section_start(const char *name, int rank)
+{
+    if (0 == rank) {
+        printf("ompio_file_info: %s: start\n", name);
+        fflush(stdout);
+    }
+}
+
+static void section_finish(const char *name, int errors_before, int ran, int rank)
+{
+    int local_failed = (errors_before != errors) ? 1 : 0;
+    int failed = 0;
+
+    MPI_Allreduce(&local_failed, &failed, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
+
+    if (0 == rank) {
+        if (SECTION_SKIPPED == ran) {
+            printf("ompio_file_info: %s: SKIP\n", name);
+        } else if (failed) {
+            printf("ompio_file_info: %s: FAIL\n", name);
+        } else {
+            printf("ompio_file_info: %s: PASS\n", name);
+        }
+        fflush(stdout);
+    }
+}
+
+static void check_rc(int rc, const char *call, int rank)
+{
+    if (MPI_SUCCESS != rc) {
+        fprintf(stderr, "[%d] %s failed with MPI error %d\n", rank, call, rc);
+        ++errors;
+    }
+}
+
+static int info_has_key(MPI_Info info, const char *key, char *value, int value_len)
+{
+    int flag = 0;
+    int buflen = value_len;
+
+    value[0] = '\0';
+    MPI_Info_get_string(info, key, &buflen, value, &flag);
+    return flag;
+}
+
+static void expect_key(MPI_Info info, const char *key, int rank)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    if (!info_has_key(info, key, value, MPI_MAX_INFO_VAL)) {
+        fprintf(stderr, "[%d] expected key %s was not returned\n", rank, key);
+        ++errors;
+    }
+}
+
+static void expect_value(MPI_Info info, const char *key, const char *expected, int rank)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    if (!info_has_key(info, key, value, MPI_MAX_INFO_VAL)) {
+        fprintf(stderr, "[%d] expected key %s was not returned\n", rank, key);
+        ++errors;
+        return;
+    }
+
+    if (0 != strcmp(value, expected)) {
+        fprintf(stderr, "[%d] expected %s=%s, got %s\n", rank, key, expected, value);
+        ++errors;
+    }
+}
+
+static void expect_no_key(MPI_Info info, const char *key, int rank)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    if (info_has_key(info, key, value, MPI_MAX_INFO_VAL)) {
+        fprintf(stderr, "[%d] unexpected key %s=%s was returned\n", rank, key, value);
+        ++errors;
+    }
+}
+
+static void expect_absent_or_not_value(MPI_Info info, const char *key,
+                                       const char *rejected, int rank)
+{
+    char value[MPI_MAX_INFO_VAL + 1];
+
+    if (info_has_key(info, key, value, MPI_MAX_INFO_VAL)
+        && 0 == strcmp(value, rejected)) {
+        fprintf(stderr, "[%d] unexpected %s=%s was returned\n", rank, key, value);
+        ++errors;
+    }
+}
+
+static void expect_same_optional_value(MPI_Info info, const char *key,
+                                       int expected_flag, const char *expected,
+                                       int rank)
+{
+    if (expected_flag) {
+        expect_value(info, key, expected, rank);
+    } else {
+        expect_no_key(info, key, rank);
+    }
+}
+
+static void make_filename_in_dir(char *filename, size_t filename_len,
+                                 const char *dir, const char *tag, int rank)
+{
+    const char *jobid;
+    char jobid_buf[32];
+
+    if (0 == rank) {
+        jobid = getenv("PMIX_NAMESPACE");
+        if (NULL == jobid) {
+            snprintf(jobid_buf, sizeof(jobid_buf), "%ld", (long) getpid());
+            jobid = jobid_buf;
+        }
+
+        snprintf(filename, filename_len, "%s/ompio-file-info-%s-%s.dat",
+                 dir, tag, jobid);
+    }
+
+    MPI_Bcast(filename, (int) filename_len, MPI_CHAR, 0, MPI_COMM_WORLD);
+}
+
+static void make_filename(char *filename, size_t filename_len, int rank)
+{
+    const char *tmpdir;
+
+    tmpdir = getenv("TMPDIR");
+    if (NULL == tmpdir) {
+        tmpdir = "/tmp";
+    }
+
+    make_filename_in_dir(filename, filename_len, tmpdir, "generic", rank);
+}
+
+static void check_default_info(const char *filename, int rank)
+{
+    MPI_File fh;
+    MPI_Info info_used;
+    int rc;
+
+    rc = MPI_File_open(MPI_COMM_WORLD, filename,
+                       MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_DELETE_ON_CLOSE,
+                       MPI_INFO_NULL, &fh);
+    check_rc(rc, "MPI_File_open", rank);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_key(info_used, "cb_buffer_size", rank);
+        expect_absent_or_not_value(info_used, "cb_nodes", "-1", rank);
+        expect_key(info_used, "collective_buffering", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_close(&fh);
+    check_rc(rc, "MPI_File_close", rank);
+}
+
+static void check_user_info(const char *filename, int rank)
+{
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    MPI_Datatype filetype = MPI_DATATYPE_NULL;
+    char cb_nodes_value[MPI_MAX_INFO_VAL + 1];
+    char collective_buffering_value[MPI_MAX_INFO_VAL + 1];
+    int cb_nodes_flag = 0;
+    int collective_buffering_flag = 0;
+    int filetype_ready = 0;
+    int rc;
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+
+    rc = MPI_Info_set(info, "cb_buffer_size", "12345");
+    check_rc(rc, "MPI_Info_set", rank);
+    rc = MPI_Info_set(info, "unknown_ompio_hint", "ignore-me");
+    check_rc(rc, "MPI_Info_set", rank);
+
+    rc = MPI_File_open(MPI_COMM_WORLD, filename,
+                       MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_DELETE_ON_CLOSE,
+                       info, &fh);
+    check_rc(rc, "MPI_File_open", rank);
+    MPI_Info_free(&info);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+    rc = MPI_File_set_errhandler(fh, MPI_ERRORS_RETURN);
+    check_rc(rc, "MPI_File_set_errhandler", rank);
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "cb_buffer_size", "12345", rank);
+        expect_no_key(info_used, "unknown_ompio_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_Info_set(info, "cb_buffer_size", "23456");
+        check_rc(rc, "MPI_Info_set", rank);
+        rc = MPI_Info_set(info, "unknown_ompio_hint", "still-ignore-me");
+        check_rc(rc, "MPI_Info_set", rank);
+
+        rc = MPI_File_set_info(fh, info);
+        check_rc(rc, "MPI_File_set_info", rank);
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "cb_buffer_size", "23456", rank);
+        cb_nodes_flag = info_has_key(info_used, "cb_nodes", cb_nodes_value,
+                                     MPI_MAX_INFO_VAL);
+        if (cb_nodes_flag && 0 == strcmp(cb_nodes_value, "-1")) {
+            fprintf(stderr, "[%d] unexpected cb_nodes=-1 was returned\n", rank);
+            ++errors;
+        }
+        collective_buffering_flag = info_has_key(info_used, "collective_buffering",
+                                                 collective_buffering_value,
+                                                 MPI_MAX_INFO_VAL);
+        if (!collective_buffering_flag) {
+            fprintf(stderr, "[%d] expected key collective_buffering was not returned\n", rank);
+            ++errors;
+        }
+        expect_no_key(info_used, "unknown_ompio_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_Info_set(info, "unknown_ompio_hint", "unknown-only");
+        check_rc(rc, "MPI_Info_set", rank);
+
+        rc = MPI_File_set_info(fh, info);
+        check_rc(rc, "MPI_File_set_info", rank);
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "cb_buffer_size", "23456", rank);
+        expect_same_optional_value(info_used, "cb_nodes", cb_nodes_flag,
+                                   cb_nodes_value, rank);
+        expect_same_optional_value(info_used, "collective_buffering",
+                                   collective_buffering_flag,
+                                   collective_buffering_value, rank);
+        expect_no_key(info_used, "unknown_ompio_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_Type_contiguous(2, MPI_BYTE, &filetype);
+    check_rc(rc, "MPI_Type_contiguous", rank);
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_Type_commit(&filetype);
+        check_rc(rc, "MPI_Type_commit", rank);
+        if (MPI_SUCCESS == rc) {
+            filetype_ready = 1;
+        }
+    }
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS == rc) {
+        if (filetype_ready) {
+            rc = MPI_Info_set(info, "cb_nodes", "1");
+            check_rc(rc, "MPI_Info_set", rank);
+            rc = MPI_Info_set(info, "collective_buffering", "false");
+            check_rc(rc, "MPI_Info_set", rank);
+            rc = MPI_Info_set(info, "unknown_ompio_hint", "set-view-ignore-me");
+            check_rc(rc, "MPI_Info_set", rank);
+
+            rc = MPI_File_set_view(fh, 0, MPI_BYTE, filetype, "native", info);
+            check_rc(rc, "MPI_File_set_view", rank);
+        }
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "cb_buffer_size", "23456", rank);
+        expect_value(info_used, "cb_nodes", "1", rank);
+        expect_value(info_used, "collective_buffering", "false", rank);
+        expect_no_key(info_used, "unknown_ompio_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS == rc) {
+        if (filetype_ready) {
+            rc = MPI_Info_set(info, "unknown_ompio_hint", "unknown-only-set-view");
+            check_rc(rc, "MPI_Info_set", rank);
+
+            rc = MPI_File_set_view(fh, 0, MPI_BYTE, filetype, "native", info);
+            check_rc(rc, "MPI_File_set_view", rank);
+        }
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "cb_buffer_size", "23456", rank);
+        expect_value(info_used, "cb_nodes", "1", rank);
+        expect_value(info_used, "collective_buffering", "false", rank);
+        expect_no_key(info_used, "unknown_ompio_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_Info_set(info, "cb_buffer_size", "34567");
+        check_rc(rc, "MPI_Info_set", rank);
+        rc = MPI_Info_set(info, "cb_nodes", "2");
+        check_rc(rc, "MPI_Info_set", rank);
+        rc = MPI_Info_set(info, "collective_buffering", "true");
+        check_rc(rc, "MPI_Info_set", rank);
+
+        rc = MPI_File_set_view(fh, 0, MPI_INT, MPI_BYTE, "native", info);
+        if (MPI_SUCCESS == rc) {
+            fprintf(stderr, "[%d] MPI_File_set_view unexpectedly succeeded\n", rank);
+            ++errors;
+        }
+        MPI_Info_free(&info);
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "cb_buffer_size", "23456", rank);
+        expect_value(info_used, "cb_nodes", "1", rank);
+        expect_value(info_used, "collective_buffering", "false", rank);
+        expect_no_key(info_used, "unknown_ompio_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    if (MPI_DATATYPE_NULL != filetype) {
+        rc = MPI_Type_free(&filetype);
+        check_rc(rc, "MPI_Type_free", rank);
+    }
+
+    rc = MPI_File_close(&fh);
+    check_rc(rc, "MPI_File_close", rank);
+}
+
+static void check_sharedfp_info(const char *filename, int rank)
+{
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    char value[MPI_MAX_INFO_VAL + 1];
+    int rc;
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+
+    rc = MPI_Info_set(info, "OMPIO_SHAREDFP_RELAXED_ORDERING", "true");
+    check_rc(rc, "MPI_Info_set", rank);
+    rc = MPI_Info_set(info, "unknown_sharedfp_hint", "ignore-me");
+    check_rc(rc, "MPI_Info_set", rank);
+
+    rc = MPI_File_open(MPI_COMM_WORLD, filename,
+                       MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_DELETE_ON_CLOSE,
+                       info, &fh);
+    check_rc(rc, "MPI_File_open", rank);
+    MPI_Info_free(&info);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        /*
+         * This hint is public only if sharedfp/individual wins selection.
+         * Some builds prefer another sharedfp component even with the hint,
+         * so absence is a valid result; presence must still preserve the
+         * accepted user value.
+         */
+        if (info_has_key(info_used, "OMPIO_SHAREDFP_RELAXED_ORDERING",
+                         value, MPI_MAX_INFO_VAL)
+            && 0 != strcmp(value, "true")) {
+            fprintf(stderr, "[%d] expected OMPIO_SHAREDFP_RELAXED_ORDERING=true, got %s\n",
+                    rank, value);
+            ++errors;
+        }
+        expect_no_key(info_used, "unknown_sharedfp_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_close(&fh);
+    check_rc(rc, "MPI_File_close", rank);
+}
+
+/*
+ * MPI-5.0 sections 11.4.3 and 14.2.8: MPI_File_get_info must report
+ * "mpi_memory_alloc_kinds", and for a file derived from the World Model
+ * its value must be identical to the value reported by MPI_COMM_GET_INFO
+ * on MPI_COMM_WORLD.  When the user asserts a supported set of kinds via
+ * "mpi_assert_memory_alloc_kinds" at open time, that key must round-trip
+ * identically alongside "mpi_memory_alloc_kinds".
+ *
+ * Open MPI only populates "mpi_memory_alloc_kinds" when the kinds were
+ * requested, so main() requests "system" (always supported) before
+ * MPI_Init.  If the key is still not reported (for example, the MCA
+ * parameter was pinned to a different value in the launch environment),
+ * there is no reference value to check against and the section is
+ * treated as skipped.  The value is compared against whatever
+ * MPI_COMM_WORLD reports rather than a hard-coded spelling, since the
+ * library may return additional supported kinds.
+ */
+static int check_memkind_info(const char *filename, int rank)
+{
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    char world_kinds[MPI_MAX_INFO_VAL + 1];
+    int rc;
+
+    rc = MPI_Comm_get_info(MPI_COMM_WORLD, &info_used);
+    check_rc(rc, "MPI_Comm_get_info", rank);
+    if (MPI_SUCCESS != rc) {
+        return SECTION_RAN;
+    }
+    if (!info_has_key(info_used, "mpi_memory_alloc_kinds", world_kinds,
+                      MPI_MAX_INFO_VAL)) {
+        MPI_Info_free(&info_used);
+        return SECTION_SKIPPED;
+    }
+    MPI_Info_free(&info_used);
+
+    /*
+     * A file opened with MPI_INFO_NULL must still report
+     * mpi_memory_alloc_kinds, identical to the World Model value, and the
+     * key must survive both set_info (which cannot update or delete it)
+     * and set_view (which rebuilds the reported hints from a staged copy).
+     */
+    rc = MPI_File_open(MPI_COMM_WORLD, filename,
+                       MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_DELETE_ON_CLOSE,
+                       MPI_INFO_NULL, &fh);
+    check_rc(rc, "MPI_File_open", rank);
+    if (MPI_SUCCESS != rc) {
+        return SECTION_RAN;
+    }
+    rc = MPI_File_set_errhandler(fh, MPI_ERRORS_RETURN);
+    check_rc(rc, "MPI_File_set_errhandler", rank);
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "mpi_memory_alloc_kinds", world_kinds, rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_Info_set(info, "cb_buffer_size", "65536");
+        check_rc(rc, "MPI_Info_set", rank);
+        rc = MPI_File_set_info(fh, info);
+        check_rc(rc, "MPI_File_set_info", rank);
+        MPI_Info_free(&info);
+    }
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "mpi_memory_alloc_kinds", world_kinds, rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_set_view(fh, 0, MPI_BYTE, MPI_BYTE, "native", MPI_INFO_NULL);
+    check_rc(rc, "MPI_File_set_view", rank);
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "mpi_memory_alloc_kinds", world_kinds, rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_close(&fh);
+    check_rc(rc, "MPI_File_close", rank);
+
+    /*
+     * Assert a supported subset of kinds at open time.  Because "system"
+     * is supported, the implementation recognizes the assertion and
+     * MPI_File_get_info must return mpi_assert_memory_alloc_kinds
+     * identical to the supplied value, with mpi_memory_alloc_kinds still
+     * reported.
+     */
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS == rc) {
+        rc = MPI_Info_set(info, "mpi_assert_memory_alloc_kinds", "system");
+        check_rc(rc, "MPI_Info_set", rank);
+        rc = MPI_File_open(MPI_COMM_WORLD, filename,
+                           MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_DELETE_ON_CLOSE,
+                           info, &fh);
+        check_rc(rc, "MPI_File_open", rank);
+        MPI_Info_free(&info);
+        if (MPI_SUCCESS == rc) {
+            rc = MPI_File_set_errhandler(fh, MPI_ERRORS_RETURN);
+            check_rc(rc, "MPI_File_set_errhandler", rank);
+
+            rc = MPI_File_get_info(fh, &info_used);
+            check_rc(rc, "MPI_File_get_info", rank);
+            if (MPI_SUCCESS == rc) {
+                expect_value(info_used, "mpi_assert_memory_alloc_kinds",
+                             "system", rank);
+                /*
+                 * A recognized assertion narrows the reported kinds to the
+                 * asserted "system"; verifying only presence would miss a
+                 * regression that left the broader World Model value
+                 * (which also contains "mpi") in place.
+                 */
+                expect_value(info_used, "mpi_memory_alloc_kinds", "system",
+                             rank);
+                MPI_Info_free(&info_used);
+            }
+
+            rc = MPI_File_close(&fh);
+            check_rc(rc, "MPI_File_close", rank);
+        }
+    }
+
+    return SECTION_RAN;
+}
+
+static int get_optional_dir(const char *env_name, char *dir, size_t dir_len, int rank)
+{
+    const char *value = NULL;
+    int enabled = 0;
+
+    if (0 == rank) {
+        value = getenv(env_name);
+        if (NULL != value && '\0' != value[0]) {
+            enabled = 1;
+            snprintf(dir, dir_len, "%s", value);
+        }
+    }
+
+    MPI_Bcast(&enabled, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    if (!enabled) {
+        return 0;
+    }
+
+    MPI_Bcast(dir, (int) dir_len, MPI_CHAR, 0, MPI_COMM_WORLD);
+    return 1;
+}
+
+/*
+ * Lustre and GPFS components require matching filesystems and, in many
+ * builds, external development headers.  Keep their coverage in this manual
+ * test, but gate it on an explicit directory so the generic OMPIO test still
+ * runs everywhere.
+ */
+static void check_lustre_open_info(const char *filename, const char *size_key,
+                                   const char *factor_key, int rank)
+{
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    int rc;
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+
+    rc = MPI_Info_set(info, size_key, "1048576");
+    check_rc(rc, "MPI_Info_set", rank);
+    rc = MPI_Info_set(info, factor_key, "2");
+    check_rc(rc, "MPI_Info_set", rank);
+    rc = MPI_Info_set(info, "unknown_lustre_hint", "ignore-me");
+    check_rc(rc, "MPI_Info_set", rank);
+
+    rc = MPI_File_open(MPI_COMM_WORLD, filename,
+                       MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_DELETE_ON_CLOSE,
+                       info, &fh);
+    check_rc(rc, "MPI_File_open", rank);
+    MPI_Info_free(&info);
+    if (MPI_SUCCESS != rc) {
+        return;
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, size_key, "1048576", rank);
+        expect_value(info_used, factor_key, "2", rank);
+        if (0 == strcmp(size_key, "stripe_size")) {
+            expect_no_key(info_used, "striping_unit", rank);
+        } else {
+            expect_no_key(info_used, "stripe_size", rank);
+        }
+        if (0 == strcmp(factor_key, "stripe_width")) {
+            expect_no_key(info_used, "striping_factor", rank);
+        } else {
+            expect_no_key(info_used, "stripe_width", rank);
+        }
+        expect_no_key(info_used, "unknown_lustre_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_close(&fh);
+    check_rc(rc, "MPI_File_close", rank);
+}
+
+static int check_lustre_info(int rank)
+{
+    char dir[MPI_MAX_INFO_VAL + 1];
+    char filename[MPI_MAX_INFO_VAL + 128];
+
+    if (!get_optional_dir("OMPIO_FILE_INFO_LUSTRE_DIR", dir, sizeof(dir), rank)) {
+        return SECTION_SKIPPED;
+    }
+
+    make_filename_in_dir(filename, sizeof(filename), dir, "lustre-alias", rank);
+    check_lustre_open_info(filename, "stripe_size", "stripe_width", rank);
+
+    make_filename_in_dir(filename, sizeof(filename), dir, "lustre-canonical", rank);
+    check_lustre_open_info(filename, "striping_unit", "striping_factor", rank);
+
+    return SECTION_RAN;
+}
+
+static int check_gpfs_info(int rank)
+{
+    char dir[MPI_MAX_INFO_VAL + 1];
+    char filename[MPI_MAX_INFO_VAL + 128];
+    MPI_File fh;
+    MPI_Info info;
+    MPI_Info info_used;
+    int rc;
+
+    if (!get_optional_dir("OMPIO_FILE_INFO_GPFS_DIR", dir, sizeof(dir), rank)) {
+        return SECTION_SKIPPED;
+    }
+
+    make_filename_in_dir(filename, sizeof(filename), dir, "gpfs", rank);
+
+    rc = MPI_Info_create(&info);
+    check_rc(rc, "MPI_Info_create", rank);
+    if (MPI_SUCCESS != rc) {
+        return SECTION_RAN;
+    }
+
+    rc = MPI_Info_set(info, "useSIOXLib", "false");
+    check_rc(rc, "MPI_Info_set", rank);
+    rc = MPI_Info_set(info, "unknown_gpfs_hint", "ignore-me");
+    check_rc(rc, "MPI_Info_set", rank);
+
+    rc = MPI_File_open(MPI_COMM_WORLD, filename,
+                       MPI_MODE_CREATE | MPI_MODE_RDWR | MPI_MODE_DELETE_ON_CLOSE,
+                       info, &fh);
+    check_rc(rc, "MPI_File_open", rank);
+    MPI_Info_free(&info);
+    if (MPI_SUCCESS != rc) {
+        return SECTION_RAN;
+    }
+
+    rc = MPI_File_get_info(fh, &info_used);
+    check_rc(rc, "MPI_File_get_info", rank);
+    if (MPI_SUCCESS == rc) {
+        expect_value(info_used, "useSIOXLib", "false", rank);
+        expect_no_key(info_used, "unknown_gpfs_hint", rank);
+        MPI_Info_free(&info_used);
+    }
+
+    rc = MPI_File_close(&fh);
+    check_rc(rc, "MPI_File_close", rank);
+
+    return SECTION_RAN;
+}
+
+int main(int argc, char *argv[])
+{
+    char filename[MPI_MAX_INFO_VAL + 128];
+    int global_errors;
+    int errors_before;
+    int rank;
+    int ran;
+
+    /*
+     * Request a supported memory allocation kind before MPI is
+     * initialized; Open MPI reads this when it builds the World Model
+     * instance, and each rank sets it for its own instance.  This lets
+     * the memkind section run without requiring the launcher to forward
+     * the MCA parameter (e.g. mpirun -x).
+     */
+    setenv("OMPI_MCA_mpi_memory_alloc_kinds", "system", 1);
+
+    MPI_Init(&argc, &argv);
+    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+    make_filename(filename, sizeof(filename), rank);
+
+    errors_before = errors;
+    section_start("default info", rank);
+    check_default_info(filename, rank);
+    section_finish("default info", errors_before, SECTION_RAN, rank);
+
+    errors_before = errors;
+    section_start("open, set_info, and set_view info", rank);
+    check_user_info(filename, rank);
+    section_finish("open, set_info, and set_view info", errors_before,
+                   SECTION_RAN, rank);
+
+    errors_before = errors;
+    section_start("sharedfp info", rank);
+    check_sharedfp_info(filename, rank);
+    section_finish("sharedfp info", errors_before, SECTION_RAN, rank);
+
+    errors_before = errors;
+    section_start("memory allocation kinds info", rank);
+    ran = check_memkind_info(filename, rank);
+    section_finish("memory allocation kinds info", errors_before, ran, rank);
+
+    errors_before = errors;
+    section_start("Lustre info", rank);
+    ran = check_lustre_info(rank);
+    section_finish("Lustre info", errors_before, ran, rank);
+
+    errors_before = errors;
+    section_start("GPFS info", rank);
+    ran = check_gpfs_info(rank);
+    section_finish("GPFS info", errors_before, ran, rank);
+
+    MPI_Allreduce(&errors, &global_errors, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
+    if (0 == rank) {
+        printf("ompio_file_info: overall: %s\n",
+               (0 == global_errors) ? "PASS" : "FAIL");
+        fflush(stdout);
+    }
+    MPI_Finalize();
+
+    return (0 == global_errors) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/test/support/support.h b/test/support/support.h
index 8c2062ea978..0673ef25ccb 100644
--- a/test/support/support.h
+++ b/test/support/support.h
@@ -11,6 +11,7 @@
  *                         All rights reserved.
  * Copyright (c) 2024      Amazon.com, Inc. or its affiliates.
  *                         All Rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -50,9 +51,10 @@ void test_fail_stop(const char *msg, int status);
 #define test_verify(MESSAGE, EXPR)                                                         \
     do {                                                                                   \
         if (!(EXPR)) {                                                                     \
-            char s[256];                                                                   \
-            snprintf(s, sizeof(s), "%s:%d: %s: %s\n", __FILE__, __LINE__, MESSAGE, #EXPR); \
-            test_failure(s);                                                               \
+            char test_verify_msgbuf_[256];                                                 \
+            snprintf(test_verify_msgbuf_, sizeof(test_verify_msgbuf_),                      \
+                     "%s:%d: %s: %s\n", __FILE__, __LINE__, MESSAGE, #EXPR);               \
+            test_failure(test_verify_msgbuf_);                                             \
         } else {                                                                           \
             test_success();                                                                \
         }                                                                                  \
diff --git a/test/threads/Makefile.am b/test/threads/Makefile.am
index b8d1923006d..f57b4b5c2f1 100644
--- a/test/threads/Makefile.am
+++ b/test/threads/Makefile.am
@@ -23,6 +23,9 @@ AM_CPPFLAGS = -I$(top_srcdir)/test/support
 
 AM_LDFLAGS = -lpthread
 
+# Make "make check" work in an uninstalled --enable-mca-dso build tree
+include $(top_srcdir)/Makefile.mca-dso-check
+
 check_PROGRAMS = \
 	opal_thread \
 	opal_condition \
diff --git a/test/util/Makefile.am b/test/util/Makefile.am
index 397eac9e2d6..df804e8326d 100644
--- a/test/util/Makefile.am
+++ b/test/util/Makefile.am
@@ -17,6 +17,7 @@
 # Copyright (c) 2018      Intel, Inc.  All rights reserved.
 # Copyright (c) 2024      Amazon.com, Inc. or its affiliates.
 #                         All Rights reserved.
+# Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
 # $COPYRIGHT$
 #
 # Additional copyrights may follow
@@ -26,17 +27,8 @@
 
 AM_CPPFLAGS = -I$(top_srcdir)/test/support
 
-#check_PROGRAMS = \
-#        ompi_numtostr \
-#        opal_error \
-#        opal_if \
-#        opal_os_path \
-#        opal_timer \
-#        opal_os_create_dirpath \
-#        opal_argv \
-#        opal_basename \
-#        opal_path_nfs
-
+# Make "make check" work in an uninstalled --enable-mca-dso build tree
+include $(top_srcdir)/Makefile.mca-dso-check
 
 check_PROGRAMS = \
 	bipartite_graph \
@@ -44,39 +36,155 @@ check_PROGRAMS = \
 	opal_path_nfs \
         opal_json \
         opal_sha256 \
-	opal_timer
+	opal_timer \
+	opal_string_copy \
+	opal_numtostr \
+	opal_basename \
+	opal_os_path \
+	opal_getcwd \
+	opal_argv \
+	opal_environ \
+	opal_printf \
+	opal_uri \
+	opal_qsort \
+	opal_alfg \
+	opal_crc \
+	opal_fd \
+	opal_arch \
+	opal_cmd_line \
+	opal_few \
+	opal_info_subscriber \
+	opal_keyval_parse \
+	opal_malloc \
+	opal_os_dirpath \
+	opal_path \
+	opal_proc \
+	opal_sys_limits \
+	opal_error \
+	opal_if \
+	opal_info \
+	opal_net \
+	opal_output
 
 TESTS = \
 	$(check_PROGRAMS)
 
-#ompi_numtostr_SOURCES = ompi_numtostr.c
-#ompi_numtostr_LDADD = \
-#        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-#        $(top_builddir)/test/support/libsupport.a
-#ompi_numtostr_DEPENDENCIES = $(ompi_numtostr_LDADD)
-
-#opal_error_SOURCES = opal_error.c
-#opal_error_LDADD = \
-#        $(top_builddir)/orte/libopen-rte.la \
-#opal_error_DEPENDENCIES = $(opal_error_LDADD)
-
-#opal_if_SOURCES = opal_if.c
-#opal_if_LDADD = \
-#        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-#        $(top_builddir)/test/support/libsupport.a
-#opal_if_DEPENDENCIES = $(opal_if_LDADD)
-
-#opal_argv_SOURCES = opal_argv.c
-#opal_argv_LDADD = \
-#        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-#        $(top_builddir)/test/support/libsupport.a
-#opal_argv_DEPENDENCIES = $(opal_argv_LDADD)
-
-#opal_basename_SOURCES = opal_basename.c
-#opal_basename_LDADD = \
-#        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-#        $(top_builddir)/test/support/libsupport.a
-#opal_basename_DEPENDENCIES = $(opal_basename_LDADD)
+# Common link line for the OPAL unit tests
+opal_test_ldadd = \
+	$(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
+	$(top_builddir)/test/support/libsupport.a
+
+opal_string_copy_SOURCES = opal_string_copy.c
+opal_string_copy_LDADD = $(opal_test_ldadd)
+opal_string_copy_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_numtostr_SOURCES = opal_numtostr.c
+opal_numtostr_LDADD = $(opal_test_ldadd)
+opal_numtostr_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_basename_SOURCES = opal_basename.c
+opal_basename_LDADD = $(opal_test_ldadd)
+opal_basename_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_os_path_SOURCES = opal_os_path.c
+opal_os_path_LDADD = $(opal_test_ldadd)
+opal_os_path_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_getcwd_SOURCES = opal_getcwd.c
+opal_getcwd_LDADD = $(opal_test_ldadd)
+opal_getcwd_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_argv_SOURCES = opal_argv.c
+opal_argv_LDADD = $(opal_test_ldadd)
+opal_argv_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_environ_SOURCES = opal_environ.c
+opal_environ_LDADD = $(opal_test_ldadd)
+opal_environ_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_printf_SOURCES = opal_printf.c
+opal_printf_LDADD = $(opal_test_ldadd)
+opal_printf_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_uri_SOURCES = opal_uri.c
+opal_uri_LDADD = $(opal_test_ldadd)
+opal_uri_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_qsort_SOURCES = opal_qsort.c
+opal_qsort_LDADD = $(opal_test_ldadd)
+opal_qsort_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_alfg_SOURCES = opal_alfg.c
+opal_alfg_LDADD = $(opal_test_ldadd)
+opal_alfg_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_crc_SOURCES = opal_crc.c
+opal_crc_LDADD = $(opal_test_ldadd)
+opal_crc_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_fd_SOURCES = opal_fd.c
+opal_fd_LDADD = $(opal_test_ldadd)
+opal_fd_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_arch_SOURCES = opal_arch.c
+opal_arch_LDADD = $(opal_test_ldadd)
+opal_arch_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_cmd_line_SOURCES = opal_cmd_line.c
+opal_cmd_line_LDADD = $(opal_test_ldadd)
+opal_cmd_line_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_few_SOURCES = opal_few.c
+opal_few_LDADD = $(opal_test_ldadd)
+opal_few_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_info_subscriber_SOURCES = opal_info_subscriber.c
+opal_info_subscriber_LDADD = $(opal_test_ldadd)
+opal_info_subscriber_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_keyval_parse_SOURCES = opal_keyval_parse.c
+opal_keyval_parse_LDADD = $(opal_test_ldadd)
+opal_keyval_parse_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_malloc_SOURCES = opal_malloc.c
+opal_malloc_LDADD = $(opal_test_ldadd)
+opal_malloc_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_os_dirpath_SOURCES = opal_os_dirpath.c
+opal_os_dirpath_LDADD = $(opal_test_ldadd)
+opal_os_dirpath_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_path_SOURCES = opal_path.c
+opal_path_LDADD = $(opal_test_ldadd)
+opal_path_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_proc_SOURCES = opal_proc.c
+opal_proc_LDADD = $(opal_test_ldadd)
+opal_proc_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_sys_limits_SOURCES = opal_sys_limits.c
+opal_sys_limits_LDADD = $(opal_test_ldadd)
+opal_sys_limits_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_error_SOURCES = opal_error.c
+opal_error_LDADD = $(opal_test_ldadd)
+opal_error_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_if_SOURCES = opal_if.c
+opal_if_LDADD = $(opal_test_ldadd)
+opal_if_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_info_SOURCES = opal_info.c
+opal_info_LDADD = $(opal_test_ldadd)
+opal_info_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_net_SOURCES = opal_net.c
+opal_net_LDADD = $(opal_test_ldadd)
+opal_net_DEPENDENCIES = $(opal_test_ldadd)
+
+opal_output_SOURCES = opal_output.c
+opal_output_LDADD = $(opal_test_ldadd)
+opal_output_DEPENDENCIES = $(opal_test_ldadd)
 
 opal_bit_ops_SOURCES = opal_bit_ops.c
 opal_bit_ops_LDADD = \
@@ -90,43 +198,12 @@ opal_path_nfs_LDADD = \
         $(top_builddir)/test/support/libsupport.a
 opal_path_nfs_DEPENDENCIES = $(opal_path_nfs_LDADD)
 
-#opal_os_path_SOURCES = opal_os_path.c
-#opal_os_path_LDADD = \
-#        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-#        $(top_builddir)/test/support/libsupport.a
-#opal_os_path_DEPENDENCIES = $(opal_os_path_LDADD)
-
 opal_timer_SOURCES = opal_timer.c
 opal_timer_LDADD = \
         $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
         $(top_builddir)/test/support/libsupport.a
 opal_timer_DEPENDENCIES = $(opal_timer_LDADD)
 
-
-#orte_sys_info_SOURCES = orte_sys_info.c
-#orte_sys_info_LDADD = \
-#        $(top_builddir)/orte/libopen-rte.la \
-#        $(top_builddir)/test/support/libsupport.a
-#orte_sys_info_DEPENDENCIES = $(orte_sys_info_LDADD)
-
-#opal_os_create_dirpath_SOURCES = opal_os_create_dirpath.c
-#opal_os_create_dirpath_LDADD = \
-#        $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
-#        $(top_builddir)/test/support/libsupport.a
-#opal_os_create_dirpath_DEPENDENCIES = $(opal_os_create_dirpath_LDADD)
-
-#orte_session_dir_SOURCES = orte_session_dir.c
-#orte_session_dir_LDADD = \
-#        $(top_builddir)/orte/libopen-rte.la \
-#        $(top_builddir)/test/support/libsupport.a
-#orte_session_dir_DEPENDENCIES = $(orte_session_dir_LDADD)
-
-#orte_universe_setup_file_io_SOURCES = orte_universe_setup_file_io.c
-#orte_universe_setup_file_io_LDADD = \
-#        $(top_builddir)/orte/libopen-rte.la \
-#        $(top_builddir)/test/support/libsupport.a
-#orte_universe_setup_file_io_DEPENDENCIES = $(orte_universe_setup_file_io_LDADD)
-
 bipartite_graph_SOURCES = bipartite_graph.c
 bipartite_graph_LDADD = \
         $(top_builddir)/opal/lib@OPAL_LIB_NAME@.la \
diff --git a/test/util/ompi_numtostr.c b/test/util/ompi_numtostr.c
deleted file mode 100644
index 16861cb91f9..00000000000
--- a/test/util/ompi_numtostr.c
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "ompi_config.h"
-#include "opal/util/numtostr.h"
-
-#include <stdio.h>
-#include <string.h>
-
-#include "support.h"
-
-int main(int argc, char *argv[])
-{
-    char *tst;
-    char *expected;
-
-    test_init("ompi_numtostr_t");
-
-    tst = opal_ltostr(10);
-    expected = malloc(sizeof(long) * 8);
-    snprintf(expected, sizeof(long) * 8, "%d", 10);
-    if (strcmp(tst, expected) != 0) {
-        test_failure("opal_ltostr test failed");
-    } else {
-        test_success();
-    }
-
-    free(tst);
-    free(expected);
-
-    tst = opal_dtostr(5.32);
-    expected = malloc(sizeof(long) * 8);
-    snprintf(expected, sizeof(long) * 8, "%f", 5.32);
-    if (strcmp(tst, expected) != 0) {
-        test_failure("opal_dtostr test failed");
-    } else {
-        test_success();
-    }
-
-    test_finalize();
-
-    return 0;
-}
diff --git a/test/util/opal_alfg.c b/test/util/opal_alfg.c
new file mode 100644
index 00000000000..aa0b7b8e7ea
--- /dev/null
+++ b/test/util/opal_alfg.c
@@ -0,0 +1,315 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+#include "opal/util/alfg.h"
+#include "opal/constants.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Number of values to draw per sequence in divergence/determinism tests */
+#define SEQ_LEN 256
+
+/* -----------------------------------------------------------------------
+ * opal_srand return value
+ * ----------------------------------------------------------------------- */
+
+static void test_srand_returns_one(void)
+{
+    opal_rng_buff_t buff;
+    int rc;
+
+    rc = opal_srand(&buff, 12345u);
+    /* NOTE: unlike other OPAL functions, opal_srand returns 1 on success */
+    test_verify("opal_srand returns 1", 1 == rc);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_rand: a drawn sequence is not a single constant value
+ * ----------------------------------------------------------------------- */
+
+static void test_rand_not_constant(void)
+{
+    opal_rng_buff_t buff;
+    uint32_t first;
+    uint32_t v;
+    int i;
+    int any_differ = 0;
+
+    opal_srand(&buff, 99999u);
+    first = opal_rand(&buff);
+    for (i = 1; i < SEQ_LEN; i++) {
+        v = opal_rand(&buff);
+        if (v != first) {
+            any_differ = 1;
+        }
+    }
+
+    test_verify("opal_rand: sequence is not a single constant value", any_differ);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_rand determinism: same seed -> same sequence
+ * ----------------------------------------------------------------------- */
+
+static void test_rand_deterministic(void)
+{
+    opal_rng_buff_t buff1, buff2;
+    uint32_t seq1[SEQ_LEN];
+    uint32_t seq2[SEQ_LEN];
+    int i;
+    int deterministic = 1;
+
+    opal_srand(&buff1, 42u);
+    opal_srand(&buff2, 42u);
+
+    for (i = 0; i < SEQ_LEN; i++) {
+        seq1[i] = opal_rand(&buff1);
+        seq2[i] = opal_rand(&buff2);
+        if (seq1[i] != seq2[i]) {
+            deterministic = 0;
+        }
+    }
+
+    test_verify("opal_rand: same seed produces identical sequences", deterministic);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_rand divergence: different seeds produce different sequences
+ * ----------------------------------------------------------------------- */
+
+static void test_rand_divergence(void)
+{
+    opal_rng_buff_t buffA, buffB;
+    uint32_t seqA[SEQ_LEN];
+    uint32_t seqB[SEQ_LEN];
+    int i;
+    int any_differ = 0;
+
+    opal_srand(&buffA, 1u);
+    opal_srand(&buffB, 2u);
+
+    for (i = 0; i < SEQ_LEN; i++) {
+        seqA[i] = opal_rand(&buffA);
+        seqB[i] = opal_rand(&buffB);
+        if (seqA[i] != seqB[i]) {
+            any_differ = 1;
+        }
+    }
+
+    test_verify("opal_rand: different seeds produce different sequences", any_differ);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_rand: re-seeding with same seed resets to same sequence
+ * ----------------------------------------------------------------------- */
+
+static void test_rand_reseed(void)
+{
+    opal_rng_buff_t buff;
+    uint32_t first[SEQ_LEN];
+    uint32_t second[SEQ_LEN];
+    int i;
+    int same = 1;
+
+    opal_srand(&buff, 777u);
+    for (i = 0; i < SEQ_LEN; i++) {
+        first[i] = opal_rand(&buff);
+    }
+
+    /* Re-seed with the same value */
+    opal_srand(&buff, 777u);
+    for (i = 0; i < SEQ_LEN; i++) {
+        second[i] = opal_rand(&buff);
+        if (first[i] != second[i]) {
+            same = 0;
+        }
+    }
+
+    test_verify("opal_rand: re-seeding with same seed restores sequence", same);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_rand: seed=0 does not crash and produces a sequence
+ * ----------------------------------------------------------------------- */
+
+static void test_rand_seed_zero(void)
+{
+    opal_rng_buff_t buff;
+    int rc;
+    uint32_t v;
+
+    rc = opal_srand(&buff, 0u);
+    test_verify("opal_srand with seed=0 returns 1", 1 == rc);
+    v = opal_rand(&buff);
+    (void) v;
+    test_verify("opal_rand after seed=0: no crash", 1);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_rand: seed=UINT32_MAX does not crash
+ * ----------------------------------------------------------------------- */
+
+static void test_rand_seed_max(void)
+{
+    opal_rng_buff_t buff;
+    int rc;
+    uint32_t v;
+
+    rc = opal_srand(&buff, UINT32_MAX);
+    test_verify("opal_srand with seed=UINT32_MAX returns 1", 1 == rc);
+    v = opal_rand(&buff);
+    (void) v;
+    test_verify("opal_rand after seed=UINT32_MAX: no crash", 1);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_rand: buffer state is independent across two buffers
+ * ----------------------------------------------------------------------- */
+
+static void test_rand_independent_buffers(void)
+{
+    opal_rng_buff_t buffX, buffY;
+    uint32_t x1, x2, y1, y2;
+
+    opal_srand(&buffX, 10u);
+    opal_srand(&buffY, 20u);
+
+    /* Advance each buffer by a different amount */
+    x1 = opal_rand(&buffX);
+    x2 = opal_rand(&buffX);
+    y1 = opal_rand(&buffY);
+    y2 = opal_rand(&buffY);
+
+    /* Confirm they don't interfere by re-seeding X and checking it */
+    opal_rng_buff_t buffX2;
+    opal_srand(&buffX2, 10u);
+    test_verify("opal_rand: buffX is independent of buffY (first value)",
+                x1 == opal_rand(&buffX2));
+    test_verify("opal_rand: buffX is independent of buffY (second value)",
+                x2 == opal_rand(&buffX2));
+
+    (void) y1;
+    (void) y2;
+}
+
+/* -----------------------------------------------------------------------
+ * opal_random (global wrapper)
+ * ----------------------------------------------------------------------- */
+
+static void test_random_range(void)
+{
+    int v;
+    int i;
+    int all_nonneg = 1;
+
+    /* Seed the global buffer first via a buff; the implementation copies
+     * from buff into the global alfg_buffer inside opal_srand. */
+    opal_rng_buff_t buff;
+    opal_srand(&buff, 55555u);
+
+    for (i = 0; i < SEQ_LEN; i++) {
+        v = opal_random();
+        /* opal_random masks with 0x7FFFFFFF -> always non-negative */
+        if (v < 0) {
+            all_nonneg = 0;
+        }
+    }
+
+    test_verify("opal_random: all values are non-negative", all_nonneg);
+}
+
+static void test_random_deterministic_via_global(void)
+{
+    opal_rng_buff_t buff;
+    int seq1[SEQ_LEN];
+    int seq2[SEQ_LEN];
+    int i;
+    int same = 1;
+
+    /* First run */
+    opal_srand(&buff, 12u);
+    for (i = 0; i < SEQ_LEN; i++) {
+        seq1[i] = opal_random();
+    }
+
+    /* Re-seed global to same value and re-draw */
+    opal_srand(&buff, 12u);
+    for (i = 0; i < SEQ_LEN; i++) {
+        seq2[i] = opal_random();
+        if (seq1[i] != seq2[i]) {
+            same = 0;
+        }
+    }
+
+    test_verify("opal_random: same global seed produces same sequence", same);
+}
+
+static void test_random_not_always_zero(void)
+{
+    opal_rng_buff_t buff;
+    int i;
+    int any_nonzero = 0;
+
+    opal_srand(&buff, 1u);
+    for (i = 0; i < SEQ_LEN; i++) {
+        if (0 != opal_random()) {
+            any_nonzero = 1;
+            break;
+        }
+    }
+
+    test_verify("opal_random: produces non-zero values", any_nonzero);
+}
+
+/* -----------------------------------------------------------------------
+ * main
+ * ----------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_alfg");
+
+    /* opal_srand */
+    test_srand_returns_one();
+    test_rand_seed_zero();
+    test_rand_seed_max();
+
+    /* opal_rand */
+    test_rand_not_constant();
+    test_rand_deterministic();
+    test_rand_divergence();
+    test_rand_reseed();
+    test_rand_independent_buffers();
+
+    /* opal_random */
+    test_random_range();
+    test_random_deterministic_via_global();
+    test_random_not_always_zero();
+
+    return test_finalize();
+}
diff --git a/test/util/opal_arch.c b/test/util/opal_arch.c
new file mode 100644
index 00000000000..41248b3792e
--- /dev/null
+++ b/test/util/opal_arch.c
@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal_arch_{init,checkmask,set_fortran_logical_size}.
+ *
+ * KEY FACTS derived from arch.h documentation:
+ *
+ * opal_arch_checkmask(var, mask) returns:
+ *    1   -- all bits in mask are set in *var  (match)
+ *    0   -- mask bits are NOT all set in *var (no match)
+ *   -1   -- *var does not have valid header bits (HEADERMASK in byte-1)
+ *           and cannot be corrected by byte-swapping.
+ *
+ * A valid arch id must have OPAL_ARCH_HEADERMASK set in the high byte (byte 1
+ * of the layout: bits 25-26 of the 32-bit word, i.e., 0x03000000).
+ * OPAL_ARCH_HEADERMASK2 (0x00000003) is the "other end" sentinel and must NOT
+ * be set for a straightforwardly valid id (the swap path is for byte-swapped
+ * remote arch ids).
+ *
+ * Zero-valued encoding macros: LONGIS32 (0), BOOLIS8 (0), LOGICALIS8 (0),
+ * LONGDOUBLEIS64 (0), LDEXPSIZEIS11 (0), LDMANTDIGIS53 (0).
+ * Asserting checkmask on a 0-valued mask is always 1 when the header is
+ * valid; we therefore only use non-zero mask values in assertions.
+ *
+ * opal_arch_init() and opal_arch_set_fortran_logical_size() only OR bits
+ * into opal_local_arch; they never clear bits.  Test interactions are noted
+ * in each sub-test.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/arch.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdlib.h>
+
+/* ------------------------------------------------------------------ */
+/* test_checkmask_valid_header                                         */
+/*                                                                     */
+/* Build a hand-crafted valid arch id (HEADERMASK set, HEADERMASK2    */
+/* clear) and exercise the trichotomy of return values.               */
+/* ------------------------------------------------------------------ */
+static void test_checkmask_valid_header(void)
+{
+    /* A minimal valid id: header bits set and LONGIS64 set. */
+    uint32_t v;
+    int32_t r;
+
+    v = OPAL_ARCH_HEADERMASK | OPAL_ARCH_LONGIS64;
+
+    /* mask matches: expect 1 */
+    r = opal_arch_checkmask(&v, OPAL_ARCH_LONGIS64);
+    test_verify("checkmask: matching non-zero mask returns 1", 1 == r);
+
+    /* mask does not match: BOOLIS16 is not set; expect 0 */
+    v = OPAL_ARCH_HEADERMASK | OPAL_ARCH_LONGIS64;
+    r = opal_arch_checkmask(&v, OPAL_ARCH_BOOLIS16);
+    test_verify("checkmask: non-matching non-zero mask returns 0", 0 == r);
+
+    /* multiple bits in mask: LONGIS64 | BOOLIS16 -- only LONGIS64 is set */
+    v = OPAL_ARCH_HEADERMASK | OPAL_ARCH_LONGIS64;
+    r = opal_arch_checkmask(&v, OPAL_ARCH_LONGIS64 | OPAL_ARCH_BOOLIS16);
+    test_verify("checkmask: partial mask match returns 0", 0 == r);
+
+    /* all bits of compound mask are set: both LONGIS64 and BOOLIS16 */
+    v = OPAL_ARCH_HEADERMASK | OPAL_ARCH_LONGIS64 | OPAL_ARCH_BOOLIS16;
+    r = opal_arch_checkmask(&v, OPAL_ARCH_LONGIS64 | OPAL_ARCH_BOOLIS16);
+    test_verify("checkmask: all bits of compound mask set returns 1", 1 == r);
+
+    /* ISBIGENDIAN mask -- test both states */
+    v = OPAL_ARCH_HEADERMASK | OPAL_ARCH_ISBIGENDIAN;
+    r = opal_arch_checkmask(&v, OPAL_ARCH_ISBIGENDIAN);
+    test_verify("checkmask: ISBIGENDIAN set -> match returns 1", 1 == r);
+
+    v = OPAL_ARCH_HEADERMASK; /* no ISBIGENDIAN */
+    r = opal_arch_checkmask(&v, OPAL_ARCH_ISBIGENDIAN);
+    test_verify("checkmask: ISBIGENDIAN not set -> match returns 0", 0 == r);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_checkmask_invalid_header                                       */
+/*                                                                     */
+/* An id with no header bits and no HEADERMASK2 bits is invalid; the  */
+/* function must return -1.                                            */
+/* ------------------------------------------------------------------ */
+static void test_checkmask_invalid_header(void)
+{
+    /* Neither HEADERMASK (0x03000000) nor HEADERMASK2 (0x00000003) set. */
+    uint32_t v = OPAL_ARCH_LONGIS64; /* no header at all */
+    int32_t r = opal_arch_checkmask(&v, OPAL_ARCH_LONGIS64);
+    test_verify("checkmask: no header bits returns -1", -1 == r);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_arch_init                                                      */
+/*                                                                     */
+/* After opal_arch_init() the global opal_local_arch must have valid  */
+/* header bits and must not have the other-end sentinel HEADERMASK2.  */
+/* ------------------------------------------------------------------ */
+static void test_arch_init(void)
+{
+    int rc;
+    uint32_t v;
+    int32_t r;
+
+    rc = opal_arch_init();
+    test_verify("opal_arch_init returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* Verify header is valid by trying a benign checkmask call. */
+    v = opal_local_arch;
+    r = opal_arch_checkmask(&v, OPAL_ARCH_LONGIS64);
+    test_verify("opal_arch_init: resulting opal_local_arch has valid header",
+                -1 != r);
+
+    /* HEADERMASK must be set. */
+    test_verify("opal_arch_init: HEADERMASK bits set",
+                0 != (opal_local_arch & OPAL_ARCH_HEADERMASK));
+}
+
+/* ------------------------------------------------------------------ */
+/* test_set_fortran_logical_size                                       */
+/*                                                                     */
+/* opal_arch_set_fortran_logical_size() ORs the appropriate           */
+/* LOGICALIS* bits into opal_local_arch.  We call it with size=2      */
+/* (LOGICALIS16, a non-zero mask value) and verify via checkmask.     */
+/*                                                                     */
+/* NOTE: Because init already ran, LOGICALIS8 (0x0) bits cannot be    */
+/* tested this way (it is the zero encoding).  We test LOGICALIS16    */
+/* and LOGICALIS32 which have non-zero bit patterns.                  */
+/* ------------------------------------------------------------------ */
+static void test_set_fortran_logical_size(void)
+{
+    int rc;
+    uint32_t v;
+    int32_t r;
+
+    /* Set logical size to 2 bytes -> LOGICALIS16 (0x00000100) */
+    rc = opal_arch_set_fortran_logical_size(2);
+    test_verify("set_fortran_logical_size(2) returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+
+    v = opal_local_arch;
+    r = opal_arch_checkmask(&v, OPAL_ARCH_LOGICALIS16);
+    test_verify("set_fortran_logical_size(2): LOGICALIS16 bit set",
+                1 == r);
+
+    /* The mask field (LOGICALISxx) should now reflect 16-bit encoding. */
+    test_verify("set_fortran_logical_size(2): LOGICALISxx field == LOGICALIS16",
+                OPAL_ARCH_LOGICALIS16 == (opal_local_arch & OPAL_ARCH_LOGICALISxx));
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    test_init("opal_arch");
+
+    opal_init_util(&argc, &argv);
+
+    /*
+     * Run checkmask tests on hand-crafted values first (no dependency on
+     * opal_arch_init state).  Then run arch_init, then set_fortran.
+     */
+    test_checkmask_valid_header();
+    test_checkmask_invalid_header();
+    test_arch_init();
+    test_set_fortran_logical_size();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_argv.c b/test/util/opal_argv.c
index 7335d46cb1b..b2189b32032 100644
--- a/test/util/opal_argv.c
+++ b/test/util/opal_argv.c
@@ -1,3 +1,4 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
 /*
  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
  *                         University Research and Technology
@@ -9,6 +10,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -16,602 +18,834 @@
  * $HEADER$
  */
 
-#include "ompi_config.h"
-#include <stdio.h>
+#include "opal_config.h"
+#include "support.h"
+#include "opal/util/argv.h"
+#include "opal/constants.h"
 #include <stdlib.h>
 #include <string.h>
 
-#include "opal/constants.h"
-#include "opal/util/argv.h"
-#include "support.h"
-
-static bool test1(void);
-static bool test2(void);
-static bool test3(void);
-static bool test4(void);
-static bool test5(void);
-static bool test6(void);
-static bool test7(void);
-static bool test8(void);
-static bool test9(void);
-static bool test10(void);
+/* ------------------------------------------------------------------ */
+/* opal_argv_append / opal_argv_append_nosize                         */
+/* ------------------------------------------------------------------ */
 
-int main(int argc, char *argv[])
+static void test_append(void)
 {
-
-    test_init("opal_argv_t");
-
-    if (test1())
-        test_success();
-    else
-        test_failure("test1 argv test failed");
-
-    if (test2())
-        test_success();
-    else
-        test_failure("test2 argv test failed");
-
-    if (test3())
-        test_success();
-    else
-        test_failure("test3 argv test failed");
-
-    if (test4())
-        test_success();
-    else
-        test_failure("test4 argv test failed");
-
-    if (test5())
-        test_success();
-    else
-        test_failure("test5 argv test failed");
-
-    if (test6())
-        test_success();
-    else
-        test_failure("test6 argv test failed");
-
-    if (test7())
-        test_success();
-    else
-        test_failure("test7 argv test failed");
-
-    if (test8())
-        test_success();
-    else
-        test_failure("test8 argv test failed");
-
-    if (test9()) {
-        test_success();
-    } else {
-        test_failure("test9 argv test failed");
-    }
-
-    if (test10()) {
-        test_success();
-    } else {
-        test_failure("test10 argv test failed");
+    char **argv = NULL;
+    int argc = 42; /* intentionally bogus -- must be reset on first call */
+
+    /* First append to NULL argv: argc is updated, array has 1 element + NULL */
+    test_verify("append first: returns OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_append(&argc, &argv, "alpha"));
+    test_verify("append first: argc == 1", 1 == argc);
+    test_verify("append first: argv non-NULL", NULL != argv);
+    test_verify("append first: argv[0] is 'alpha'",
+                0 == strcmp("alpha", argv[0]));
+    test_verify("append first: argv[1] is NULL", NULL == argv[1]);
+
+    /* Second append */
+    test_verify("append second: returns OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_append(&argc, &argv, "beta"));
+    test_verify("append second: argc == 2", 2 == argc);
+    test_verify("append second: argv[0] still 'alpha'",
+                0 == strcmp("alpha", argv[0]));
+    test_verify("append second: argv[1] is 'beta'",
+                0 == strcmp("beta", argv[1]));
+    test_verify("append second: argv[2] is NULL", NULL == argv[2]);
+
+    /* Strings are copied by value -- mutate source and verify argv unchanged */
+    {
+        char buf[] = "gamma";
+        test_verify("append copy-by-value setup",
+                    OPAL_SUCCESS == opal_argv_append(&argc, &argv, buf));
+        buf[0] = 'X';
+        test_verify("append copy-by-value: stored string unchanged",
+                    0 == strcmp("gamma", argv[2]));
     }
 
-    /* All done */
-    return test_finalize();
+    opal_argv_free(argv);
 }
 
-static bool test1(void)
+static void test_append_nosize(void)
 {
-    char *a[] = {"argv1", "argv2", "argv3", NULL};
     char **argv = NULL;
-    int i, j, argc = 28;
-
-    /* Test basic functionality.  Start with a NULL argv and add the
-       contents of the a array.
-
-       Set argc to be an initial bogus number -- opal_argv_add() should
-       reset it back to zero after the first iteration.
-
-       After adding the a[i], ensure that argv[0 - (i-1)] are the same
-       as a[0 - (i-1)].
-
-       Also ensure that a[i + 1] == NULL and that argc is the proper
-       value. */
-
-    for (i = 0; a[i] != NULL; ++i) {
-        if (opal_argv_append(&argc, &argv, a[i]) != OPAL_SUCCESS) {
-            return false;
-        }
-        for (j = 0; j <= i; ++j) {
-            if (strcmp(argv[j], a[j]) != 0) {
-                return false;
-            }
-        }
-        if (NULL != argv[i + 1]) {
-            return false;
-        }
-        if (argc != i + 1) {
-            return false;
-        }
-    }
-    opal_argv_free(argv);
 
-    return true;
-}
+    test_verify("append_nosize first: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_append_nosize(&argv, "one"));
+    test_verify("append_nosize first: argv non-NULL", NULL != argv);
+    test_verify("append_nosize first: argv[0] == 'one'",
+                0 == strcmp("one", argv[0]));
+    test_verify("append_nosize first: argv[1] == NULL", NULL == argv[1]);
 
-static bool test2(void)
-{
-    int i, j;
-    char **argv = NULL;
-    int argc;
-    char *a[] = {"aaa", "bbb", "ccc", NULL};
-    char *b[4];
-
-    /* Similar test to above, but ensure that opal_argv_add is actually
-       *copying* the string by value, not by reference.  So copy the a
-       array into b, and then opal_argv_add() from b.  After that,
-       scribble in the first character of the b[] string that we just
-       added, and compare all entries in a to argv -- they should be
-       identical (even though b is now corrupted). */
-
-    for (i = 0; a[i] != NULL; ++i) {
-        b[i] = strdup(a[i]);
-    }
-    b[i] = NULL;
-
-    for (i = 0; b[i] != NULL; ++i) {
-        if (opal_argv_append(&argc, &argv, b[i]) != OPAL_SUCCESS) {
-            return false;
-        }
-        ++b[i][0];
-        for (j = 0; j <= i; ++j) {
-            if (strcmp(argv[j], a[j]) != 0) {
-                return false;
-            }
-        }
-        if (NULL != argv[i + 1]) {
-            return false;
-        }
-        if (argc != i + 1) {
-            return false;
-        }
-    }
+    test_verify("append_nosize second: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_append_nosize(&argv, "two"));
+    test_verify("append_nosize second: argv[1] == 'two'",
+                0 == strcmp("two", argv[1]));
+    test_verify("append_nosize second: argv[2] == NULL", NULL == argv[2]);
 
     opal_argv_free(argv);
-    for (i = 0; b[i] != NULL; ++i) {
-        free(b[i]);
-    }
-
-    return true;
 }
 
-static bool test3(void)
+/* ------------------------------------------------------------------ */
+/* opal_argv_prepend_nosize                                            */
+/* ------------------------------------------------------------------ */
+
+static void test_prepend(void)
 {
-    int i;
-    int argc;
     char **argv = NULL;
-    char *a[] = {"aaa", "bbb", "ccc", NULL};
-    char *b[4];
 
-    /* Try to free a null argv -- should be harmless (we'll seg fault if
-       it's not!) */
+    /* prepend to empty array */
+    test_verify("prepend to NULL: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_prepend_nosize(&argv, "first"));
+    test_verify("prepend to NULL: argv[0] == 'first'",
+                0 == strcmp("first", argv[0]));
+    test_verify("prepend to NULL: argv[1] == NULL", NULL == argv[1]);
+
+    /* prepend a second element */
+    test_verify("prepend second: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_prepend_nosize(&argv, "zero"));
+    test_verify("prepend second: argv[0] == 'zero'",
+                0 == strcmp("zero", argv[0]));
+    test_verify("prepend second: argv[1] == 'first'",
+                0 == strcmp("first", argv[1]));
+    test_verify("prepend second: argv[2] == NULL", NULL == argv[2]);
+
+    /* prepend a third */
+    test_verify("prepend third: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_prepend_nosize(&argv, "neg1"));
+    test_verify("prepend third: argv[0] == 'neg1'",
+                0 == strcmp("neg1", argv[0]));
+    test_verify("prepend third: argv[1] == 'zero'",
+                0 == strcmp("zero", argv[1]));
+    test_verify("prepend third: argv[2] == 'first'",
+                0 == strcmp("first", argv[2]));
+    test_verify("prepend third: argv[3] == NULL", NULL == argv[3]);
 
     opal_argv_free(argv);
+}
 
-    /* Now add some stuff and try to free it.  We'll seg fault if
-       anything goes wrong.  a is on the stack, so if it mistakenly
-       tries to free it, we should get a seg fault. */
+/* ------------------------------------------------------------------ */
+/* opal_argv_append_unique_nosize                                      */
+/* ------------------------------------------------------------------ */
 
-    for (i = 0; a[i] != NULL; ++i) {
-        if (opal_argv_append(&argc, &argv, a[i]) != OPAL_SUCCESS) {
-            return false;
-        }
-    }
-    opal_argv_free(argv);
+static void test_append_unique(void)
+{
+    char **argv = NULL;
 
-    /* Do the same thing but guarantee that the copied array was from
-       the heap and was freed before we call opal_argv_free(). */
+    /* Fast path: NULL array -- appends unconditionally */
+    test_verify("unique: NULL array appends",
+                OPAL_SUCCESS == opal_argv_append_unique_nosize(&argv, "x", false));
+    test_verify("unique: NULL array: argv[0] == 'x'",
+                0 == strcmp("x", argv[0]));
+
+    /* Adding a fresh element -- should append */
+    test_verify("unique: new element appended",
+                OPAL_SUCCESS == opal_argv_append_unique_nosize(&argv, "y", false));
+    test_verify("unique: new element: count == 2",
+                2 == opal_argv_count(argv));
+
+    /* Duplicate with overwrite=false -- no change, still OPAL_SUCCESS */
+    test_verify("unique: dup overwrite=false returns OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_append_unique_nosize(&argv, "x", false));
+    test_verify("unique: dup overwrite=false: count stays 2",
+                2 == opal_argv_count(argv));
+    test_verify("unique: dup overwrite=false: argv[0] still 'x'",
+                0 == strcmp("x", argv[0]));
+
+    /* Duplicate with overwrite=true -- value replaced, count unchanged */
+    test_verify("unique: dup overwrite=true returns OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_append_unique_nosize(&argv, "x", true));
+    test_verify("unique: dup overwrite=true: count stays 2",
+                2 == opal_argv_count(argv));
+    test_verify("unique: dup overwrite=true: argv[0] still 'x'",
+                0 == strcmp("x", argv[0]));
 
-    argc = 0;
-    argv = NULL;
-    for (i = 0; a[i] != NULL; ++i) {
-        b[i] = strdup(a[i]);
-    }
-    b[i] = NULL;
-    for (i = 0; b[i] != NULL; ++i) {
-        if (opal_argv_append(&argc, &argv, b[i]) != OPAL_SUCCESS) {
-            return false;
-        }
-    }
-    for (i = 0; b[i] != NULL; ++i) {
-        free(b[i]);
-    }
     opal_argv_free(argv);
-
-    /* All done */
-
-    return true;
 }
 
-static bool test4(void)
-{
-    size_t i, count;
-    char *a = strdup("the quick  brown fox jumped over  the lazy  dog "
-                     "a_really_long_argument_to_force_a_long_copy_"
-                     "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
-                     "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");
-    char **b;
-    char *start;
-
-    /* split a string into an argv, and compare it against the original
-       string.  Add double spaces into the string; opal_argv_split()
-       should skip them. */
-
-    b = opal_argv_split(a, ' ');
-
-    for (count = i = 1; i < strlen(a); ++i) {
-        if (a[i] != ' ' && a[i - 1] == ' ') {
-            ++count;
-        }
-    }
-    for (i = 0; b[i] != NULL; ++i) {
-        continue;
-    }
-    if (i != count) {
-        return false;
-    }
+/* ------------------------------------------------------------------ */
+/* opal_argv_free                                                       */
+/* ------------------------------------------------------------------ */
 
-    /* now do the same thing and compare each token in b */
-
-    for (start = a, count = i = 0; i < strlen(a); ++i) {
-        if (a[i] == ' ' && a[i - 1] != ' ') {
-            a[i] = '\0';
-            if (strcmp(start, b[count]) != 0) {
-                return false;
-            }
-            ++count;
-            a[i] = ' ';
-        }
-        if (a[i] == ' ' && a[i + 1] != ' ') {
-            start = a + i + 1;
-        }
-    }
-    if (strcmp(start, b[count]) != 0) {
-        return false;
-    }
+static void test_free(void)
+{
+    char **argv = NULL;
+    int argc = 0;
 
-    /* all done */
+    /* free(NULL) must be a no-op */
+    opal_argv_free(NULL); /* would segfault if broken */
+    test_verify("free(NULL) is harmless", 1);
 
-    opal_argv_free(b);
-    free(a);
-    return true;
+    /* build and free a real array */
+    opal_argv_append(&argc, &argv, "a");
+    opal_argv_append(&argc, &argv, "b");
+    opal_argv_free(argv); /* would segfault or fail asan/valgrind if broken */
+    test_verify("free real array is harmless", 1);
 }
 
-static bool test5(void)
-{
-    char *a[] = {"aaa", "bbb", "ccc", NULL};
-
-    return (opal_argv_count(NULL) == 0 && opal_argv_count(a) == 3);
-}
+/* ------------------------------------------------------------------ */
+/* opal_argv_count                                                      */
+/* ------------------------------------------------------------------ */
 
-static bool test6(void)
+static void test_count(void)
 {
-    char *a = "the quick brown fox jumped over the lazy dog "
-              "a_really_long_argument_to_force_a_long_copy_"
-              "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
-              "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
-    char **b;
-    char *c;
-
-    /* split the string above and then join it -- the joined version
-       should be just like the original */
+    char *a[] = {"a", "b", "c", NULL};
 
-    b = opal_argv_split(a, ' ');
-    c = opal_argv_join(b, ' ');
+    test_verify("count(NULL) == 0", 0 == opal_argv_count(NULL));
+    test_verify("count(3-elem) == 3", 3 == opal_argv_count(a));
 
-    if (strcmp(a, c) != 0) {
-        return false;
+    /* empty array (only NULL terminator) */
+    {
+        char **empty = NULL;
+        int argc = 0;
+        opal_argv_append(&argc, &empty, "tmp");
+        /* delete all */
+        opal_argv_delete(&argc, &empty, 0, 99);
+        test_verify("count after delete-all == 0", 0 == opal_argv_count(empty));
+        opal_argv_free(empty);
     }
+}
 
-    /* All done */
+/* ------------------------------------------------------------------ */
+/* opal_argv_split / opal_argv_split_with_empty                       */
+/* ------------------------------------------------------------------ */
 
-    free(c);
-    opal_argv_free(b);
-    return true;
+static void test_split(void)
+{
+    char **result;
+
+    /* Basic split */
+    result = opal_argv_split("a:b:c", ':');
+    test_verify("split basic: non-NULL", NULL != result);
+    test_verify("split basic: count == 3", 3 == opal_argv_count(result));
+    test_verify("split basic: [0]=='a'", 0 == strcmp("a", result[0]));
+    test_verify("split basic: [1]=='b'", 0 == strcmp("b", result[1]));
+    test_verify("split basic: [2]=='c'", 0 == strcmp("c", result[2]));
+    opal_argv_free(result);
+
+    /* split skips consecutive delimiters (empty tokens) */
+    result = opal_argv_split("a::b", ':');
+    test_verify("split consecutive delimiters: count == 2",
+                2 == opal_argv_count(result));
+    test_verify("split consecutive: [0]=='a'", 0 == strcmp("a", result[0]));
+    test_verify("split consecutive: [1]=='b'", 0 == strcmp("b", result[1]));
+    opal_argv_free(result);
+
+    /* split skips leading delimiter */
+    result = opal_argv_split(":a:b", ':');
+    test_verify("split leading delim: count == 2", 2 == opal_argv_count(result));
+    test_verify("split leading: [0]=='a'", 0 == strcmp("a", result[0]));
+    opal_argv_free(result);
+
+    /* split skips trailing delimiter */
+    result = opal_argv_split("a:b:", ':');
+    test_verify("split trailing delim: count == 2", 2 == opal_argv_count(result));
+    test_verify("split trailing: [0]=='a'", 0 == strcmp("a", result[0]));
+    test_verify("split trailing: [1]=='b'", 0 == strcmp("b", result[1]));
+    opal_argv_free(result);
+
+    /* split empty string returns NULL (nothing to iterate) */
+    result = opal_argv_split("", ':');
+    test_verify("split empty string: returns NULL", NULL == result);
+    /* (no free needed for NULL) */
+
+    /* split NULL src_string returns NULL */
+    result = opal_argv_split(NULL, ':');
+    test_verify("split NULL src: returns NULL", NULL == result);
 }
 
-static bool test7(void)
+static void test_split_with_empty(void)
 {
-    char *a[] = {"a", "b", "c", NULL};
-    size_t a_len = (1 + 1 + sizeof(char *)) * 3 + sizeof(char **);
-
-    /* check a NULL pointer first -- should return 0 */
+    char **result;
+
+    /* Basic split_with_empty -- same as split for non-empty tokens */
+    result = opal_argv_split_with_empty("a:b:c", ':');
+    test_verify("split_with_empty basic: count == 3",
+                3 == opal_argv_count(result));
+    test_verify("split_with_empty basic: [0]=='a'",
+                0 == strcmp("a", result[0]));
+    opal_argv_free(result);
+
+    /* Consecutive delimiters produce empty strings */
+    result = opal_argv_split_with_empty("a::b", ':');
+    test_verify("split_with_empty consecutive: count == 3",
+                3 == opal_argv_count(result));
+    test_verify("split_with_empty consecutive: [0]=='a'",
+                0 == strcmp("a", result[0]));
+    test_verify("split_with_empty consecutive: [1]==''",
+                0 == strcmp("", result[1]));
+    test_verify("split_with_empty consecutive: [2]=='b'",
+                0 == strcmp("b", result[2]));
+    opal_argv_free(result);
+
+    /* Leading delimiter produces empty string at index 0 */
+    result = opal_argv_split_with_empty(":a", ':');
+    test_verify("split_with_empty leading: count == 2",
+                2 == opal_argv_count(result));
+    test_verify("split_with_empty leading: [0]==''",
+                0 == strcmp("", result[0]));
+    test_verify("split_with_empty leading: [1]=='a'",
+                0 == strcmp("a", result[1]));
+    opal_argv_free(result);
+
+    /* An interior empty field is included.  (Whether a *trailing*
+     * delimiter should also yield a trailing empty field is left
+     * unspecified by the documentation -- which only says "include empty
+     * strings" -- and the implementation does not produce one, so we do
+     * not assert that ambiguous case here.) */
+    result = opal_argv_split_with_empty("a::b", ':');
+    test_verify("split_with_empty interior: count == 3", 3 == opal_argv_count(result));
+    test_verify("split_with_empty interior: [0]=='a'", 0 == strcmp("a", result[0]));
+    test_verify("split_with_empty interior: [1]==''", 0 == strcmp("", result[1]));
+    test_verify("split_with_empty interior: [2]=='b'", 0 == strcmp("b", result[2]));
+    opal_argv_free(result);
+
+    /* Difference from split: split_with_empty keeps empty, split does not */
+    {
+        char **without_empty = opal_argv_split("a::b", ':');
+        char **with_empty = opal_argv_split_with_empty("a::b", ':');
+        test_verify("split vs split_with_empty differ on empty tokens",
+                    opal_argv_count(without_empty) < opal_argv_count(with_empty));
+        opal_argv_free(without_empty);
+        opal_argv_free(with_empty);
+    }
+
+    /* Empty source string */
+    result = opal_argv_split_with_empty("", ':');
+    test_verify("split_with_empty empty string: NULL", NULL == result);
+
+    /* NULL source string */
+    result = opal_argv_split_with_empty(NULL, ':');
+    test_verify("split_with_empty NULL src: NULL", NULL == result);
+}
 
-    if (opal_argv_len(NULL) != (size_t) 0) {
-        return false;
-    }
+/* ------------------------------------------------------------------ */
+/* opal_argv_join / opal_argv_join_range                              */
+/* ------------------------------------------------------------------ */
 
-    /* now check a real string */
-    /* size should be (sizeof(char **) + (sizeof(char) + sizeof('\0') +
-       sizeof(char*)) * 3) */
+static void test_join(void)
+{
+    char *joined;
 
-    if (opal_argv_len(a) != a_len) {
-        return false;
+    /* bozo cases */
+    joined = opal_argv_join(NULL, ':');
+    test_verify("join(NULL): returns non-NULL (empty string)",
+                NULL != joined);
+    test_verify("join(NULL): returns empty string",
+                0 == strcmp("", joined));
+    free(joined);
+
+    {
+        char *empty_argv[] = {NULL};
+        joined = opal_argv_join(empty_argv, ':');
+        test_verify("join(empty array): non-NULL", NULL != joined);
+        test_verify("join(empty array): empty string",
+                    0 == strcmp("", joined));
+        free(joined);
+    }
+
+    /* basic join */
+    {
+        char *a[] = {"x", "y", "z", NULL};
+        joined = opal_argv_join(a, ':');
+        test_verify("join basic: non-NULL", NULL != joined);
+        test_verify("join basic: 'x:y:z'",
+                    0 == strcmp("x:y:z", joined));
+        free(joined);
+    }
+
+    /* single element: no delimiter in output */
+    {
+        char *a[] = {"solo", NULL};
+        joined = opal_argv_join(a, ',');
+        test_verify("join single: 'solo'",
+                    0 == strcmp("solo", joined));
+        free(joined);
+    }
+
+    /* round-trip: split then join reproduces original */
+    {
+        char *orig = "the quick brown fox";
+        char **parts = opal_argv_split(orig, ' ');
+        joined = opal_argv_join(parts, ' ');
+        test_verify("join round-trip",
+                    0 == strcmp(orig, joined));
+        free(joined);
+        opal_argv_free(parts);
     }
-
-    /* All done */
-
-    return true;
 }
 
-static bool test8(void)
+static void test_join_range(void)
 {
-    char *a[] = {"aaa", "bbbbbbbb", "cccccccccc", NULL};
-    int i;
-    char **b;
-
-    /* bozo case */
-
-    if (NULL != opal_argv_copy(NULL)) {
-        return false;
-    }
+    char *joined;
+    char *a[] = {"a", "b", "c", "d", NULL};
+
+    /* bozo: NULL array */
+    joined = opal_argv_join_range(NULL, 0, 2, ':');
+    test_verify("join_range NULL array: non-NULL (empty string)",
+                NULL != joined);
+    test_verify("join_range NULL array: empty string",
+                0 == strcmp("", joined));
+    free(joined);
+
+    /* bozo: start >= count */
+    joined = opal_argv_join_range(a, 99, 100, ':');
+    test_verify("join_range start>=count: empty string",
+                0 == strcmp("", joined));
+    free(joined);
+
+    /* range [1,3) => "b:c" */
+    joined = opal_argv_join_range(a, 1, 3, '-');
+    test_verify("join_range [1,3): non-NULL", NULL != joined);
+    test_verify("join_range [1,3): 'b-c'",
+                0 == strcmp("b-c", joined));
+    free(joined);
+
+    /* range [0,4) => full array */
+    joined = opal_argv_join_range(a, 0, 4, ':');
+    test_verify("join_range [0,4): 'a:b:c:d'",
+                0 == strcmp("a:b:c:d", joined));
+    free(joined);
+
+    /* range [2,4) => "c:d" */
+    joined = opal_argv_join_range(a, 2, 4, ':');
+    test_verify("join_range [2,4): 'c:d'",
+                0 == strcmp("c:d", joined));
+    free(joined);
+
+    /* single element range [1,2) => "b" */
+    joined = opal_argv_join_range(a, 1, 2, ':');
+    test_verify("join_range single element: 'b'",
+                0 == strcmp("b", joined));
+    free(joined);
+
+    /* end beyond array: stops at NULL */
+    joined = opal_argv_join_range(a, 2, 999, ':');
+    test_verify("join_range end>count: 'c:d'",
+                0 == strcmp("c:d", joined));
+    free(joined);
+}
 
-    /* dup the a array and compare it (array length, contents, etc.) */
+/* ------------------------------------------------------------------ */
+/* opal_argv_len                                                        */
+/* ------------------------------------------------------------------ */
 
-    b = opal_argv_copy(a);
+static void test_len(void)
+{
+    /* NULL returns 0 */
+    test_verify("len(NULL) == 0", (size_t) 0 == opal_argv_len(NULL));
 
-    if (opal_argv_count(a) != opal_argv_count(b)) {
-        return false;
-    }
-    for (i = 0; a[i] != NULL; ++i) {
-        if (0 != strcmp(a[i], b[i])) {
-            return false;
-        }
+    /* ["a","b","c"]: each entry: strlen + 1 (for '\0') + sizeof(char*),
+       plus one trailing sizeof(char*) for the NULL sentinel pointer.
+       = sizeof(char*) + 3*(1+1+sizeof(char*)) */
+    {
+        char *a[] = {"a", "b", "c", NULL};
+        size_t expected = sizeof(char *) + 3 * (1 + 1 + sizeof(char *));
+        test_verify("len(['a','b','c'])", expected == opal_argv_len(a));
     }
+}
 
-    /* All done */
+/* ------------------------------------------------------------------ */
+/* opal_argv_copy                                                       */
+/* ------------------------------------------------------------------ */
 
-    opal_argv_free(b);
-    return true;
+static void test_copy(void)
+{
+    /* NULL input returns NULL */
+    test_verify("copy(NULL) == NULL", NULL == opal_argv_copy(NULL));
+
+    /* empty array (just NULL sentinel) returns a valid [NULL] array */
+    {
+        char *empty[] = {NULL};
+        char **dup = opal_argv_copy(empty);
+        test_verify("copy([NULL]): non-NULL", NULL != dup);
+        test_verify("copy([NULL]): count == 0", 0 == opal_argv_count(dup));
+        opal_argv_free(dup);
+    }
+
+    /* normal array: deep copy */
+    {
+        char *a[] = {"foo", "bar", "baz", NULL};
+        char **dup = opal_argv_copy(a);
+        test_verify("copy: non-NULL", NULL != dup);
+        test_verify("copy: count matches",
+                    opal_argv_count(a) == opal_argv_count(dup));
+        test_verify("copy: [0] matches", 0 == strcmp(a[0], dup[0]));
+        test_verify("copy: [1] matches", 0 == strcmp(a[1], dup[1]));
+        test_verify("copy: [2] matches", 0 == strcmp(a[2], dup[2]));
+        /* deep copy: different pointers */
+        test_verify("copy: [0] different pointer", a[0] != dup[0]);
+        opal_argv_free(dup);
+    }
 }
 
-static bool test9(void)
+/* ------------------------------------------------------------------ */
+/* opal_argv_delete                                                     */
+/* ------------------------------------------------------------------ */
+
+static void test_delete(void)
 {
-    char **a = NULL;
+    char **a;
     int argc;
 
-    /* bozo cases */
-
-    if (OPAL_SUCCESS != opal_argv_delete(NULL, NULL, 0, 0)) {
-        return false;
-    }
+    /* bozo: NULL argv/NULL *argv => OPAL_SUCCESS */
+    test_verify("delete(NULL,NULL): OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(NULL, NULL, 0, 0));
 
+    /* bozo: 0 num_to_delete => no-op */
     a = NULL;
     argc = 0;
-    opal_argv_append(&argc, &a, "foo");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 7, 1) || 1 != opal_argv_count(a)) {
-        return false;
-    }
+    opal_argv_append(&argc, &a, "alpha");
+    test_verify("delete 0 items: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 0, 0));
+    test_verify("delete 0 items: count unchanged", 1 == opal_argv_count(a));
     opal_argv_free(a);
 
+    /* bozo: start > count => no-op */
     a = NULL;
     argc = 0;
-    opal_argv_append(&argc, &a, "foo");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 0, 0) || 1 != opal_argv_count(a)) {
-        return false;
-    }
+    opal_argv_append(&argc, &a, "alpha");
+    test_verify("delete start>count: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 7, 1));
+    test_verify("delete start>count: count unchanged", 1 == opal_argv_count(a));
     opal_argv_free(a);
 
-    /* now some real tests */
-    /* delete 1 off the top */
+    /* bad param: negative start */
+    a = NULL;
+    argc = 0;
+    opal_argv_append(&argc, &a, "alpha");
+    test_verify("delete negative start: OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == opal_argv_delete(&argc, &a, -1, 1));
+    opal_argv_free(a);
 
+    /* delete first element */
     a = NULL;
     argc = 0;
     opal_argv_append(&argc, &a, "a");
     opal_argv_append(&argc, &a, "b");
     opal_argv_append(&argc, &a, "c");
-    opal_argv_append(&argc, &a, "d");
-    opal_argv_append(&argc, &a, "e");
-    opal_argv_append(&argc, &a, "f");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 0, 1) || 5 != opal_argv_count(a)
-        || 0 != strcmp(a[0], "b") || 0 != strcmp(a[1], "c") || 0 != strcmp(a[2], "d")
-        || 0 != strcmp(a[3], "e") || 0 != strcmp(a[4], "f")) {
-        return false;
-    }
+    test_verify("delete first: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 0, 1));
+    test_verify("delete first: count == 2", 2 == opal_argv_count(a));
+    test_verify("delete first: [0]=='b'", 0 == strcmp("b", a[0]));
+    test_verify("delete first: [1]=='c'", 0 == strcmp("c", a[1]));
     opal_argv_free(a);
 
-    /* delete 2 off the top */
-
+    /* delete from middle */
     a = NULL;
     argc = 0;
     opal_argv_append(&argc, &a, "a");
     opal_argv_append(&argc, &a, "b");
     opal_argv_append(&argc, &a, "c");
     opal_argv_append(&argc, &a, "d");
-    opal_argv_append(&argc, &a, "e");
-    opal_argv_append(&argc, &a, "f");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 0, 2) || 4 != opal_argv_count(a)
-        || 0 != strcmp(a[0], "c") || 0 != strcmp(a[1], "d") || 0 != strcmp(a[2], "e")
-        || 0 != strcmp(a[3], "f")) {
-        return false;
-    }
+    test_verify("delete middle: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 1, 2));
+    test_verify("delete middle: count == 2", 2 == opal_argv_count(a));
+    test_verify("delete middle: [0]=='a'", 0 == strcmp("a", a[0]));
+    test_verify("delete middle: [1]=='d'", 0 == strcmp("d", a[1]));
     opal_argv_free(a);
 
-    /* delete 1 in the middle */
-
+    /* delete from end */
     a = NULL;
     argc = 0;
     opal_argv_append(&argc, &a, "a");
     opal_argv_append(&argc, &a, "b");
     opal_argv_append(&argc, &a, "c");
-    opal_argv_append(&argc, &a, "d");
-    opal_argv_append(&argc, &a, "e");
-    opal_argv_append(&argc, &a, "f");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 1, 1) || 5 != opal_argv_count(a)
-        || 0 != strcmp(a[0], "a") || 0 != strcmp(a[1], "c") || 0 != strcmp(a[2], "d")
-        || 0 != strcmp(a[3], "e") || 0 != strcmp(a[4], "f")) {
-        return false;
-    }
+    test_verify("delete from end: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 2, 1));
+    test_verify("delete from end: count == 2", 2 == opal_argv_count(a));
+    test_verify("delete from end: [0]=='a'", 0 == strcmp("a", a[0]));
+    test_verify("delete from end: [1]=='b'", 0 == strcmp("b", a[1]));
     opal_argv_free(a);
 
-    /* delete 2 in the middle */
-
+    /* over-delete: num_to_delete exceeds remaining elements */
     a = NULL;
     argc = 0;
     opal_argv_append(&argc, &a, "a");
     opal_argv_append(&argc, &a, "b");
-    opal_argv_append(&argc, &a, "c");
-    opal_argv_append(&argc, &a, "d");
-    opal_argv_append(&argc, &a, "e");
-    opal_argv_append(&argc, &a, "f");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 1, 2) || 4 != opal_argv_count(a)
-        || 0 != strcmp(a[0], "a") || 0 != strcmp(a[1], "d") || 0 != strcmp(a[2], "e")
-        || 0 != strcmp(a[3], "f")) {
-        return false;
-    }
+    test_verify("delete over-delete: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 0, 99));
+    test_verify("delete over-delete: count == 0", 0 == opal_argv_count(a));
+    /* Over-deleting (asking to remove more elements than exist) must
+     * still leave argc consistent with the actual array length. */
+    test_verify("delete over-delete: argc == count", argc == opal_argv_count(a));
     opal_argv_free(a);
 
-    /* delete everything from the top */
-
+    /* delete all starting from middle */
     a = NULL;
     argc = 0;
     opal_argv_append(&argc, &a, "a");
     opal_argv_append(&argc, &a, "b");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 0, 99) || 0 != opal_argv_count(a)) {
-        return false;
-    }
+    opal_argv_append(&argc, &a, "c");
+    test_verify("delete from middle to end: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 1, 99));
+    test_verify("delete from middle to end: count == 1", 1 == opal_argv_count(a));
+    test_verify("delete from middle to end: [0]=='a'", 0 == strcmp("a", a[0]));
     opal_argv_free(a);
 
-    /* delete everything from the middle */
-
+    /* delete last of 6 */
     a = NULL;
     argc = 0;
     opal_argv_append(&argc, &a, "a");
     opal_argv_append(&argc, &a, "b");
-    if (OPAL_SUCCESS != opal_argv_delete(&argc, &a, 1, 99) || 1 != opal_argv_count(a)
-        || 0 != strcmp(a[0], "a")) {
-        return false;
-    }
+    opal_argv_append(&argc, &a, "c");
+    opal_argv_append(&argc, &a, "d");
+    opal_argv_append(&argc, &a, "e");
+    opal_argv_append(&argc, &a, "f");
+    test_verify("delete last of 6: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_delete(&argc, &a, 5, 1));
+    test_verify("delete last of 6: count == 5", 5 == opal_argv_count(a));
+    test_verify("delete last of 6: [4]=='e'", 0 == strcmp("e", a[4]));
     opal_argv_free(a);
-
-    /* All done */
-
-    return true;
 }
 
-static bool test10(void)
-{
-    char **orig;
-    char **insert;
-    int o, i;
-
-    /* bozo cases */
+/* ------------------------------------------------------------------ */
+/* opal_argv_insert                                                     */
+/* ------------------------------------------------------------------ */
 
-    orig = NULL;
-    o = 0;
-    insert = NULL;
-    i = 0;
-    opal_argv_append(&i, &insert, "insert a");
-    if (OPAL_SUCCESS == opal_argv_insert(NULL, 0, insert)) {
-        return false;
-    }
-    opal_argv_append(&o, &orig, "orig a");
-    if (OPAL_SUCCESS != opal_argv_insert(&orig, 0, NULL)) {
-        return false;
-    }
-    if (OPAL_SUCCESS == opal_argv_insert(&orig, -1, insert)) {
-        return false;
-    }
-    opal_argv_free(orig);
-    opal_argv_free(insert);
-
-    /* append to the end */
-
-    orig = NULL;
-    o = 0;
-    insert = NULL;
-    i = 0;
-    opal_argv_append(&i, &insert, "insert a");
-    opal_argv_append(&i, &insert, "insert b");
-    opal_argv_append(&i, &insert, "insert c");
-    opal_argv_append(&o, &orig, "orig a");
-    opal_argv_append(&o, &orig, "orig b");
-    opal_argv_append(&o, &orig, "orig c");
-    if (OPAL_SUCCESS != opal_argv_insert(&orig, 99, insert) || 6 != opal_argv_count(orig)
-        || 0 != strcmp(orig[0], "orig a") || 0 != strcmp(orig[1], "orig b")
-        || 0 != strcmp(orig[2], "orig c") || 0 != strcmp(orig[3], "insert a")
-        || 0 != strcmp(orig[4], "insert b") || 0 != strcmp(orig[5], "insert c")) {
-        return false;
-    }
-    opal_argv_free(orig);
-    opal_argv_free(insert);
-
-    /* insert at the beginning */
-
-    orig = NULL;
-    o = 0;
-    insert = NULL;
-    i = 0;
-    opal_argv_append(&i, &insert, "insert a");
-    opal_argv_append(&i, &insert, "insert b");
-    opal_argv_append(&i, &insert, "insert c");
-    opal_argv_append(&o, &orig, "orig a");
-    opal_argv_append(&o, &orig, "orig b");
-    opal_argv_append(&o, &orig, "orig c");
-    if (OPAL_SUCCESS != opal_argv_insert(&orig, 0, insert) || 6 != opal_argv_count(orig)
-        || 0 != strcmp(orig[3], "orig a") || 0 != strcmp(orig[4], "orig b")
-        || 0 != strcmp(orig[5], "orig c") || 0 != strcmp(orig[0], "insert a")
-        || 0 != strcmp(orig[1], "insert b") || 0 != strcmp(orig[2], "insert c")) {
-        return false;
-    }
-    opal_argv_free(orig);
-    opal_argv_free(insert);
+static void test_insert(void)
+{
+    char **target;
+    char **source;
+    int t, s;
+
+    /* bozo: NULL target => OPAL_ERR_BAD_PARAM */
+    test_verify("insert NULL target: OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == opal_argv_insert(NULL, 0, NULL));
+
+    /* bozo: *target is NULL => OPAL_ERR_BAD_PARAM */
+    {
+        char **p = NULL;
+        test_verify("insert *target==NULL: OPAL_ERR_BAD_PARAM",
+                    OPAL_ERR_BAD_PARAM == opal_argv_insert(&p, 0, NULL));
+    }
+
+    /* bozo: negative start => OPAL_ERR_BAD_PARAM */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "orig a");
+    test_verify("insert negative start: OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == opal_argv_insert(&target, -1, NULL));
+    opal_argv_free(target);
+
+    /* NULL source => no-op, OPAL_SUCCESS */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "orig a");
+    test_verify("insert NULL source: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert(&target, 0, NULL));
+    test_verify("insert NULL source: count unchanged", 1 == opal_argv_count(target));
+    opal_argv_free(target);
+
+    /* append to end (start > count) */
+    target = NULL;
+    t = 0;
+    source = NULL;
+    s = 0;
+    opal_argv_append(&t, &target, "orig a");
+    opal_argv_append(&t, &target, "orig b");
+    opal_argv_append(&s, &source, "ins a");
+    opal_argv_append(&s, &source, "ins b");
+    test_verify("insert beyond end: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert(&target, 99, source));
+    test_verify("insert beyond end: count == 4", 4 == opal_argv_count(target));
+    test_verify("insert beyond end: [0]=='orig a'",
+                0 == strcmp("orig a", target[0]));
+    test_verify("insert beyond end: [2]=='ins a'",
+                0 == strcmp("ins a", target[2]));
+    test_verify("insert beyond end: [3]=='ins b'",
+                0 == strcmp("ins b", target[3]));
+    opal_argv_free(target);
+    opal_argv_free(source);
+
+    /* insert at position 0 (beginning) */
+    target = NULL;
+    t = 0;
+    source = NULL;
+    s = 0;
+    opal_argv_append(&t, &target, "orig a");
+    opal_argv_append(&t, &target, "orig b");
+    opal_argv_append(&t, &target, "orig c");
+    opal_argv_append(&s, &source, "ins a");
+    opal_argv_append(&s, &source, "ins b");
+    opal_argv_append(&s, &source, "ins c");
+    test_verify("insert at 0: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert(&target, 0, source));
+    test_verify("insert at 0: count == 6", 6 == opal_argv_count(target));
+    test_verify("insert at 0: [0]=='ins a'",
+                0 == strcmp("ins a", target[0]));
+    test_verify("insert at 0: [1]=='ins b'",
+                0 == strcmp("ins b", target[1]));
+    test_verify("insert at 0: [2]=='ins c'",
+                0 == strcmp("ins c", target[2]));
+    test_verify("insert at 0: [3]=='orig a'",
+                0 == strcmp("orig a", target[3]));
+    test_verify("insert at 0: [4]=='orig b'",
+                0 == strcmp("orig b", target[4]));
+    test_verify("insert at 0: [5]=='orig c'",
+                0 == strcmp("orig c", target[5]));
+    opal_argv_free(target);
+    opal_argv_free(source);
 
     /* insert in the middle */
+    target = NULL;
+    t = 0;
+    source = NULL;
+    s = 0;
+    opal_argv_append(&t, &target, "orig a");
+    opal_argv_append(&t, &target, "orig b");
+    opal_argv_append(&t, &target, "orig c");
+    opal_argv_append(&s, &source, "ins a");
+    opal_argv_append(&s, &source, "ins b");
+    test_verify("insert middle: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert(&target, 1, source));
+    test_verify("insert middle: count == 5", 5 == opal_argv_count(target));
+    test_verify("insert middle: [0]=='orig a'",
+                0 == strcmp("orig a", target[0]));
+    test_verify("insert middle: [1]=='ins a'",
+                0 == strcmp("ins a", target[1]));
+    test_verify("insert middle: [2]=='ins b'",
+                0 == strcmp("ins b", target[2]));
+    test_verify("insert middle: [3]=='orig b'",
+                0 == strcmp("orig b", target[3]));
+    test_verify("insert middle: [4]=='orig c'",
+                0 == strcmp("orig c", target[4]));
+    opal_argv_free(target);
+    opal_argv_free(source);
+}
 
-    orig = NULL;
-    o = 0;
-    insert = NULL;
-    i = 0;
-    opal_argv_append(&i, &insert, "insert a");
-    opal_argv_append(&i, &insert, "insert b");
-    opal_argv_append(&i, &insert, "insert c");
-    opal_argv_append(&o, &orig, "orig a");
-    opal_argv_append(&o, &orig, "orig b");
-    opal_argv_append(&o, &orig, "orig c");
-    if (OPAL_SUCCESS != opal_argv_insert(&orig, 1, insert) || 6 != opal_argv_count(orig)
-        || 0 != strcmp(orig[0], "orig a") || 0 != strcmp(orig[4], "orig b")
-        || 0 != strcmp(orig[5], "orig c") || 0 != strcmp(orig[1], "insert a")
-        || 0 != strcmp(orig[2], "insert b") || 0 != strcmp(orig[3], "insert c")) {
-        return false;
-    }
-    opal_argv_free(orig);
-    opal_argv_free(insert);
+/* ------------------------------------------------------------------ */
+/* opal_argv_insert_element                                            */
+/* ------------------------------------------------------------------ */
+
+static void test_insert_element(void)
+{
+    char **target;
+    int t;
+    char elem[] = "NEW";
+
+    /* bozo: NULL target */
+    test_verify("insert_element NULL target: OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == opal_argv_insert_element(NULL, 0, elem));
+
+    /* bozo: *target is NULL */
+    {
+        char **p = NULL;
+        test_verify("insert_element *target==NULL: OPAL_ERR_BAD_PARAM",
+                    OPAL_ERR_BAD_PARAM == opal_argv_insert_element(&p, 0, elem));
+    }
+
+    /* bozo: negative location */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "a");
+    test_verify("insert_element negative loc: OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == opal_argv_insert_element(&target, -1, elem));
+    opal_argv_free(target);
+
+    /* NULL source element: no-op */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "a");
+    test_verify("insert_element NULL source: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert_element(&target, 0, NULL));
+    test_verify("insert_element NULL source: count unchanged",
+                1 == opal_argv_count(target));
+    opal_argv_free(target);
+
+    /* insert at position 0 (front) */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "a");
+    opal_argv_append(&t, &target, "b");
+    opal_argv_append(&t, &target, "c");
+    test_verify("insert_element at 0: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert_element(&target, 0, elem));
+    test_verify("insert_element at 0: count == 4", 4 == opal_argv_count(target));
+    test_verify("insert_element at 0: [0]=='NEW'",
+                0 == strcmp("NEW", target[0]));
+    test_verify("insert_element at 0: [1]=='a'",
+                0 == strcmp("a", target[1]));
+    test_verify("insert_element at 0: [2]=='b'",
+                0 == strcmp("b", target[2]));
+    test_verify("insert_element at 0: [3]=='c'",
+                0 == strcmp("c", target[3]));
+    opal_argv_free(target);
 
     /* insert in the middle */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "a");
+    opal_argv_append(&t, &target, "b");
+    opal_argv_append(&t, &target, "c");
+    test_verify("insert_element middle: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert_element(&target, 1, elem));
+    test_verify("insert_element middle: count == 4", 4 == opal_argv_count(target));
+    test_verify("insert_element middle: [0]=='a'",
+                0 == strcmp("a", target[0]));
+    test_verify("insert_element middle: [1]=='NEW'",
+                0 == strcmp("NEW", target[1]));
+    test_verify("insert_element middle: [2]=='b'",
+                0 == strcmp("b", target[2]));
+    test_verify("insert_element middle: [3]=='c'",
+                0 == strcmp("c", target[3]));
+    opal_argv_free(target);
+
+    /* insert at end (location == count) */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "a");
+    opal_argv_append(&t, &target, "b");
+    test_verify("insert_element at count (end): OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert_element(&target, 2, elem));
+    test_verify("insert_element at end: count == 3", 3 == opal_argv_count(target));
+    test_verify("insert_element at end: [0]=='a'",
+                0 == strcmp("a", target[0]));
+    test_verify("insert_element at end: [1]=='b'",
+                0 == strcmp("b", target[1]));
+    test_verify("insert_element at end: [2]=='NEW'",
+                0 == strcmp("NEW", target[2]));
+    opal_argv_free(target);
+
+    /* insert beyond end (location > count): appended */
+    target = NULL;
+    t = 0;
+    opal_argv_append(&t, &target, "a");
+    test_verify("insert_element beyond end: OPAL_SUCCESS",
+                OPAL_SUCCESS == opal_argv_insert_element(&target, 99, elem));
+    test_verify("insert_element beyond end: count == 2",
+                2 == opal_argv_count(target));
+    test_verify("insert_element beyond end: [1]=='NEW'",
+                0 == strcmp("NEW", target[1]));
+    opal_argv_free(target);
+}
 
-    orig = NULL;
-    o = 0;
-    insert = NULL;
-    i = 0;
-    opal_argv_append(&i, &insert, "insert a");
-    opal_argv_append(&i, &insert, "insert b");
-    opal_argv_append(&i, &insert, "insert c");
-    opal_argv_append(&o, &orig, "orig a");
-    opal_argv_append(&o, &orig, "orig b");
-    opal_argv_append(&o, &orig, "orig c");
-    opal_argv_append(&o, &orig, "orig d");
-    opal_argv_append(&o, &orig, "orig e");
-    opal_argv_append(&o, &orig, "orig f");
-    if (OPAL_SUCCESS != opal_argv_insert(&orig, 1, insert) || 9 != opal_argv_count(orig)
-        || 0 != strcmp(orig[0], "orig a") || 0 != strcmp(orig[4], "orig b")
-        || 0 != strcmp(orig[5], "orig c") || 0 != strcmp(orig[6], "orig d")
-        || 0 != strcmp(orig[7], "orig e") || 0 != strcmp(orig[8], "orig f")
-        || 0 != strcmp(orig[1], "insert a") || 0 != strcmp(orig[2], "insert b")
-        || 0 != strcmp(orig[3], "insert c")) {
-        return false;
-    }
-    opal_argv_free(orig);
-    opal_argv_free(insert);
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
 
-    /* All done */
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_argv");
+
+    test_append();
+    test_append_nosize();
+    test_prepend();
+    test_append_unique();
+    test_free();
+    test_count();
+    test_split();
+    test_split_with_empty();
+    test_join();
+    test_join_range();
+    test_len();
+    test_copy();
+    test_delete();
+    test_insert();
+    test_insert_element();
 
-    return true;
+    return test_finalize();
 }
diff --git a/test/util/opal_basename.c b/test/util/opal_basename.c
index 65de549ccca..b871f552492 100644
--- a/test/util/opal_basename.c
+++ b/test/util/opal_basename.c
@@ -10,6 +10,7 @@
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
  * Copyright (c) 2018      Amazon.com, Inc. or its affiliates.  All Rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -17,49 +18,145 @@
  * $HEADER$
  */
 
-#include "ompi_config.h"
+#include "opal_config.h"
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "opal/util/basename.h"
-#include "opal/util/printf.h"
 #include "support.h"
+#include "opal/util/basename.h"
+#include "opal/constants.h"
 
-static void test(const char *in, const char *out);
-
-int main(int argc, char *argv[])
+/* Helper that tests opal_basename and frees the result. */
+static void check_basename(const char *input, const char *expected)
 {
-    test_init("opal_basename()");
-
-    test("foo.txt", "foo.txt");
-    test("/foo/bar/baz", "baz");
-    test("/yow.c", "yow.c");
-    test("/", "/");
+    char *result = opal_basename(input);
+    char msg[256];
 
-    test("foo.txt/", "foo.txt");
-    test("/foo/bar/baz/", "baz");
-    test("/yow.c/", "yow.c");
-    test("//", "/");
+    if (NULL == expected) {
+        snprintf(msg, sizeof(msg),
+                 "basename(NULL): expected NULL, got '%s'",
+                 result ? result : "(null)");
+        test_verify(msg, NULL == result);
+        /* result should already be NULL here, but free defensively */
+        if (NULL != result) {
+            free(result);
+        }
+        return;
+    }
 
-    /* All done */
-    return test_finalize();
+    snprintf(msg, sizeof(msg),
+             "basename(\"%s\"): expected \"%s\", got \"%s\"",
+             input ? input : "(null)", expected,
+             result ? result : "(null)");
+    test_verify(msg, NULL != result && 0 == strcmp(result, expected));
+    if (NULL != result) {
+        free(result);
+    }
 }
 
-void test(const char *in, const char *out)
+/* Helper that tests opal_dirname and frees the result. */
+static void check_dirname(const char *input, const char *expected)
 {
-    char *msg;
-    char *ret = opal_basename(in);
-
-    if (0 == strcmp(ret, out)) {
-        test_success();
-    } else {
-        opal_asprintf(&msg, "Mismatch: input \"%s\", expected \"%s\", got \"%s\"\n", in, out, ret);
-        test_failure(msg);
-        free(msg);
+    char *result = opal_dirname(input);
+    char msg[256];
+
+    snprintf(msg, sizeof(msg),
+             "dirname(\"%s\"): expected \"%s\", got \"%s\"",
+             input ? input : "(null)", expected,
+             result ? result : "(null)");
+    test_verify(msg, NULL != result && 0 == strcmp(result, expected));
+    if (NULL != result) {
+        free(result);
     }
-    if (NULL != ret) {
-        free(ret);
+}
+
+int main(int argc, char *argv[])
+{
+    test_init("opal_basename_dirname");
+
+    /* ================================================================
+     * opal_basename() tests
+     * ================================================================ */
+
+    /* NULL input -> NULL return */
+    check_basename(NULL, NULL);
+
+    /* Empty string -> empty string */
+    check_basename("", "");
+
+    /* No slash -> entire string */
+    check_basename("foo.txt", "foo.txt");
+    check_basename("foo", "foo");
+
+    /* Absolute paths */
+    check_basename("/foo/bar/baz", "baz");
+    check_basename("/yow.c", "yow.c");
+
+    /* Root: "/" -> "/" */
+    check_basename("/", "/");
+
+    /* Trailing slash is stripped */
+    check_basename("foo.txt/", "foo.txt");
+    check_basename("/foo/bar/baz/", "baz");
+    check_basename("/yow.c/", "yow.c");
+
+    /* Double trailing slash */
+    check_basename("//", "/");
+
+    /* Multiple trailing slashes on a path */
+    check_basename("/foo/bar///", "bar");
+
+    /* Single component with trailing slash */
+    check_basename("onlyone/", "onlyone");
+
+    /* Dot and dot-dot */
+    check_basename(".", ".");
+    check_basename("..", "..");
+
+    /* ================================================================
+     * opal_dirname() tests
+     *
+     * NOTE: The header's documentation examples for opal_dirname() are
+     * incorrect -- they list "foo.txt" -> "foo.txt" and "/" -> "", which
+     * are basename examples, not dirname. We assert POSIX dirname(3)
+     * behavior, which is the authoritative reference and matches the
+     * libc-delegating implementation used on systems that have dirname().
+     * ================================================================ */
+
+    /* No slash -> "." (POSIX dirname of a bare filename) */
+    check_dirname("foo.txt", ".");
+    check_dirname("foo", ".");
+
+    /* Absolute paths */
+    check_dirname("/foo/bar/baz", "/foo/bar");
+    check_dirname("/yow.c", "/");
+
+    /* Root: "/" -> "/" (POSIX) */
+    check_dirname("/", "/");
+
+    /* Trailing slash: POSIX dirname treats trailing slashes as if stripped */
+    check_dirname("/foo/bar/baz/", "/foo/bar");
+    check_dirname("/usr/", "/");
+
+    /* Two-level */
+    check_dirname("/a/b", "/a");
+
+    /* Single component absolute */
+    check_dirname("/single", "/");
+
+    /* Dot */
+    check_dirname(".", ".");
+
+    /* opal_dirname(NULL) is guarded (mirroring opal_basename) and
+       returns NULL rather than dereferencing the NULL pointer. */
+    {
+        char *d = opal_dirname(NULL);
+        test_verify("dirname(NULL) returns NULL", NULL == d);
+        if (NULL != d) {
+            free(d);
+        }
     }
+
+    return test_finalize();
 }
diff --git a/test/util/opal_cmd_line.c b/test/util/opal_cmd_line.c
new file mode 100644
index 00000000000..d0b284e2d4e
--- /dev/null
+++ b/test/util/opal_cmd_line.c
@@ -0,0 +1,937 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit test for opal_cmd_line_t and its full public API.
+ *
+ * Coverage targets (opal/util/cmd_line.c, 539 lines, 0% prior coverage):
+ *   opal_cmd_line_create, opal_cmd_line_add, opal_cmd_line_make_opt_mca,
+ *   opal_cmd_line_make_opt3, opal_cmd_line_parse, opal_cmd_line_get_usage_msg,
+ *   opal_cmd_line_is_taken, opal_cmd_line_get_ninsts, opal_cmd_line_get_param,
+ *   opal_cmd_line_get_argc, opal_cmd_line_get_argv, opal_cmd_line_get_tail.
+ *   Also exercises internally: make_opt, find_option, split_shorts, set_dest,
+ *   free_parse_results, fill, qsort_callback, get_help_otype, build_parsable.
+ *
+ * NOTE: -DNDEBUG is set; assert() is a no-op. All verification uses
+ * test_verify().  Do NOT use assert().
+ *
+ * NOTE: The cmd_line module uses opal_output / MCA / opal classes, so
+ * opal_init_util() is required before any cmd_line calls.
+ */
+
+#include "opal_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "support.h"
+
+#include "opal/util/cmd_line.h"
+#include "opal/util/argv.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+/* -----------------------------------------------------------------------
+ * Forward declarations
+ * ----------------------------------------------------------------------- */
+static void test_make_opt3_errors(void);
+static void test_create_and_add(void);
+static void test_make_opt_mca(void);
+static void test_parse_flags(void);
+static void test_parse_option_with_params(void);
+static void test_get_param_documented_example(void);
+static void test_parse_multiple_instances(void);
+static void test_parse_single_dash_name(void);
+static void test_combined_shorts(void);
+static void test_parse_double_dash_separator(void);
+static void test_parse_unknown_option_error(void);
+static void test_parse_missing_param_error(void);
+static void test_parse_ignore_unknown(void);
+static void test_get_argc_and_argv(void);
+static void test_get_tail(void);
+static void test_get_ninsts_unregistered(void);
+static void test_get_usage_msg(void);
+static void test_set_dest_variable(void);
+static void test_reparse(void);
+static void test_set_dest_int_invalid(void);
+
+/* -----------------------------------------------------------------------
+ * main
+ * ----------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    int rc;
+
+    test_init("opal_cmd_line");
+
+    rc = opal_init_util(&argc, &argv);
+    test_verify("opal_init_util succeeds", OPAL_SUCCESS == rc);
+    if (OPAL_SUCCESS != rc) {
+        return test_finalize();
+    }
+
+    test_make_opt3_errors();
+    test_create_and_add();
+    test_make_opt_mca();
+    test_parse_flags();
+    test_parse_option_with_params();
+    test_get_param_documented_example();
+    test_parse_multiple_instances();
+    test_parse_single_dash_name();
+    test_combined_shorts();
+    test_parse_double_dash_separator();
+    test_parse_unknown_option_error();
+    test_parse_missing_param_error();
+    test_parse_ignore_unknown();
+    test_get_argc_and_argv();
+    test_get_tail();
+    test_get_ninsts_unregistered();
+    test_get_usage_msg();
+    test_set_dest_variable();
+    test_set_dest_int_invalid();
+    test_reparse();
+
+    opal_finalize_util();
+
+    return test_finalize();
+}
+
+/* -----------------------------------------------------------------------
+ * test_make_opt3_errors -- error paths in make_opt / make_opt3
+ * ----------------------------------------------------------------------- */
+static void test_make_opt3_errors(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+
+    /* All three name arguments NULL/'\0' must fail */
+    rc = opal_cmd_line_make_opt3(&cmd, '\0', NULL, NULL, 0, "no names");
+    test_verify("make_opt3 all-empty names returns ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == rc);
+
+    /* num_params < 0 must fail */
+    rc = opal_cmd_line_make_opt3(&cmd, 'x', NULL, NULL, -1, "neg params");
+    test_verify("make_opt3 num_params<0 returns ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == rc);
+
+    /* Valid option must succeed */
+    rc = opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose mode");
+    test_verify("make_opt3 valid short+long succeeds",
+                OPAL_SUCCESS == rc);
+
+    /* Duplicate long name must fail */
+    rc = opal_cmd_line_make_opt3(&cmd, '\0', NULL, "verbose", 0, "Dup");
+    test_verify("make_opt3 duplicate long name returns ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == rc);
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_create_and_add -- opal_cmd_line_create + opal_cmd_line_add
+ * ----------------------------------------------------------------------- */
+static void test_create_and_add(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    /* Table-driven create */
+    opal_cmd_line_init_t table[] = {
+        { NULL, 'h', NULL, "help", 0,
+          NULL, OPAL_CMD_LINE_TYPE_NULL,
+          "This help message", OPAL_CMD_LINE_OTYPE_GENERAL },
+
+        { NULL, 'n', NULL, "numprocs", 1,
+          NULL, OPAL_CMD_LINE_TYPE_NULL,
+          "Number of processes", OPAL_CMD_LINE_OTYPE_GENERAL },
+
+        /* Sentinel */
+        { NULL, '\0', NULL, NULL, 0,
+          NULL, OPAL_CMD_LINE_TYPE_NULL, NULL, OPAL_CMD_LINE_OTYPE_NULL }
+    };
+
+    rc = opal_cmd_line_create(&cmd, table);
+    test_verify("opal_cmd_line_create returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* Extend with an additional option via opal_cmd_line_add */
+    opal_cmd_line_init_t extra[] = {
+        { NULL, 'd', NULL, "debug", 0,
+          NULL, OPAL_CMD_LINE_TYPE_NULL,
+          "Enable debug", OPAL_CMD_LINE_OTYPE_DEBUG },
+
+        { NULL, '\0', NULL, NULL, 0,
+          NULL, OPAL_CMD_LINE_TYPE_NULL, NULL, OPAL_CMD_LINE_OTYPE_NULL }
+    };
+    rc = opal_cmd_line_add(&cmd, extra);
+    test_verify("opal_cmd_line_add returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* NULL table is legal (no-op) */
+    rc = opal_cmd_line_add(&cmd, NULL);
+    test_verify("opal_cmd_line_add(NULL table) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* Before parsing: nothing is taken */
+    test_verify("is_taken('help') before parse == false",
+                !opal_cmd_line_is_taken(&cmd, "help"));
+    test_verify("get_ninsts('numprocs') before parse == 0",
+                0 == opal_cmd_line_get_ninsts(&cmd, "numprocs"));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_make_opt_mca -- opal_cmd_line_make_opt_mca
+ * ----------------------------------------------------------------------- */
+static void test_make_opt_mca(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+
+    opal_cmd_line_init_t entry = {
+        NULL,           /* ocl_mca_param_name */
+        'q',            /* ocl_cmd_short_name */
+        NULL,           /* ocl_cmd_single_dash_name */
+        "quiet",        /* ocl_cmd_long_name */
+        0,              /* ocl_num_params */
+        NULL,           /* ocl_variable_dest */
+        OPAL_CMD_LINE_TYPE_NULL,
+        "Quiet mode",   /* ocl_description */
+        OPAL_CMD_LINE_OTYPE_GENERAL
+    };
+    rc = opal_cmd_line_make_opt_mca(&cmd, entry);
+    test_verify("make_opt_mca valid entry returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* All-empty sentinel is a no-op, not an error */
+    opal_cmd_line_init_t sentinel = {
+        NULL, '\0', NULL, NULL, 0,
+        NULL, OPAL_CMD_LINE_TYPE_NULL, NULL, OPAL_CMD_LINE_OTYPE_NULL
+    };
+    rc = opal_cmd_line_make_opt_mca(&cmd, sentinel);
+    test_verify("make_opt_mca sentinel returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_flags -- zero-param options (flags)
+ * ----------------------------------------------------------------------- */
+static void test_parse_flags(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+    opal_cmd_line_make_opt3(&cmd, 'd', NULL, "debug",   0, "Debug");
+    opal_cmd_line_make_opt3(&cmd, 'q', NULL, "quiet",   0, "Quiet");
+
+    /* Parse: program verbose debug; quiet absent */
+    char *args[] = { "prog", "--verbose", "--debug", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 3, args);
+    test_verify("parse flags returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("is_taken('verbose') == true",
+                opal_cmd_line_is_taken(&cmd, "verbose"));
+    test_verify("is_taken('v') == true (short alias)",
+                opal_cmd_line_is_taken(&cmd, "v"));
+    test_verify("is_taken('debug') == true",
+                opal_cmd_line_is_taken(&cmd, "debug"));
+    test_verify("is_taken('quiet') == false (not passed)",
+                !opal_cmd_line_is_taken(&cmd, "quiet"));
+
+    test_verify("get_ninsts('verbose') == 1", 1 == opal_cmd_line_get_ninsts(&cmd, "verbose"));
+    test_verify("get_ninsts('debug') == 1",   1 == opal_cmd_line_get_ninsts(&cmd, "debug"));
+    test_verify("get_ninsts('quiet') == 0",   0 == opal_cmd_line_get_ninsts(&cmd, "quiet"));
+
+    /* Zero-param option: get_param returns NULL (no parameter tokens recorded) */
+    test_verify("get_param(verbose,0,0) == NULL for zero-param option",
+                NULL == opal_cmd_line_get_param(&cmd, "verbose", 0, 0));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_option_with_params -- options that take string parameters
+ * ----------------------------------------------------------------------- */
+static void test_parse_option_with_params(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    char *p;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'o', NULL, "output",  1, "Output file");
+    opal_cmd_line_make_opt3(&cmd, 'n', NULL, "numprocs",1, "Num procs");
+
+    char *args[] = { "prog", "--output", "results.txt", "-n", "8", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 5, args);
+    test_verify("parse with params returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("is_taken('output') == true",
+                opal_cmd_line_is_taken(&cmd, "output"));
+    test_verify("is_taken('o') == true (short)",
+                opal_cmd_line_is_taken(&cmd, "o"));
+    test_verify("is_taken('numprocs') == true",
+                opal_cmd_line_is_taken(&cmd, "numprocs"));
+
+    p = opal_cmd_line_get_param(&cmd, "output", 0, 0);
+    test_verify("get_param(output,0,0) non-NULL", NULL != p);
+    test_verify("get_param(output,0,0) == 'results.txt'",
+                NULL != p && 0 == strcmp("results.txt", p));
+
+    p = opal_cmd_line_get_param(&cmd, "numprocs", 0, 0);
+    test_verify("get_param(numprocs,0,0) non-NULL", NULL != p);
+    test_verify("get_param(numprocs,0,0) == '8'",
+                NULL != p && 0 == strcmp("8", p));
+
+    /* Out-of-range instance and param index both return NULL */
+    test_verify("get_param(output,1,0) == NULL (instance out of range)",
+                NULL == opal_cmd_line_get_param(&cmd, "output", 1, 0));
+    test_verify("get_param(output,0,1) == NULL (param index out of range)",
+                NULL == opal_cmd_line_get_param(&cmd, "output", 0, 1));
+
+    /* Unknown option name returns NULL */
+    test_verify("get_param on unknown opt == NULL",
+                NULL == opal_cmd_line_get_param(&cmd, "nonexistent", 0, 0));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_get_param_documented_example -- exact example from cmd_line.h
+ *
+ * From header: executable --foo bar1 bar2 --foo bar3 bar4
+ *   get_param(cmd, "foo", 1, 1) == "bar4"
+ *   get_param(cmd, "bar", 0, 0) == NULL   (unregistered)
+ *   get_param(cmd, "foo", 2, 2) == NULL   (inst 2 doesn't exist)
+ * ----------------------------------------------------------------------- */
+static void test_get_param_documented_example(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    char *p;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    /* "foo" takes 2 parameters */
+    opal_cmd_line_make_opt3(&cmd, '\0', NULL, "foo", 2, "Foo option");
+
+    char *args[] = {
+        "executable",
+        "--foo", "bar1", "bar2",
+        "--foo", "bar3", "bar4",
+        NULL
+    };
+    rc = opal_cmd_line_parse(&cmd, false, false, 7, args);
+    test_verify("documented example parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("get_ninsts('foo') == 2",
+                2 == opal_cmd_line_get_ninsts(&cmd, "foo"));
+
+    /* Instance 0, param 0 -> "bar1" */
+    p = opal_cmd_line_get_param(&cmd, "foo", 0, 0);
+    test_verify("get_param(foo,0,0) == 'bar1'",
+                NULL != p && 0 == strcmp("bar1", p));
+
+    /* Instance 0, param 1 -> "bar2" */
+    p = opal_cmd_line_get_param(&cmd, "foo", 0, 1);
+    test_verify("get_param(foo,0,1) == 'bar2'",
+                NULL != p && 0 == strcmp("bar2", p));
+
+    /* Instance 1, param 0 -> "bar3" */
+    p = opal_cmd_line_get_param(&cmd, "foo", 1, 0);
+    test_verify("get_param(foo,1,0) == 'bar3'",
+                NULL != p && 0 == strcmp("bar3", p));
+
+    /* Header documented example: instance 1, param 1 -> "bar4" */
+    p = opal_cmd_line_get_param(&cmd, "foo", 1, 1);
+    test_verify("get_param(foo,1,1) == 'bar4' [documented example]",
+                NULL != p && 0 == strcmp("bar4", p));
+
+    /* Header documented example: unregistered option -> NULL */
+    p = opal_cmd_line_get_param(&cmd, "bar", 0, 0);
+    test_verify("get_param(bar,0,0) == NULL [documented: unregistered]",
+                NULL == p);
+
+    /* Header documented example: instance 2 doesn't exist -> NULL */
+    p = opal_cmd_line_get_param(&cmd, "foo", 2, 2);
+    test_verify("get_param(foo,2,2) == NULL [documented: no third instance]",
+                NULL == p);
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_multiple_instances -- same option repeated on command line
+ * ----------------------------------------------------------------------- */
+static void test_parse_multiple_instances(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    char *p;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'I', NULL, "include", 1, "Include path");
+
+    char *args[] = {
+        "prog",
+        "--include", "/usr/include",
+        "--include", "/opt/include",
+        "--include", "/home/user/include",
+        NULL
+    };
+    rc = opal_cmd_line_parse(&cmd, false, false, 7, args);
+    test_verify("multiple instances parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("is_taken('include') == true",
+                opal_cmd_line_is_taken(&cmd, "include"));
+    test_verify("get_ninsts('include') == 3",
+                3 == opal_cmd_line_get_ninsts(&cmd, "include"));
+
+    p = opal_cmd_line_get_param(&cmd, "include", 0, 0);
+    test_verify("include instance 0 == '/usr/include'",
+                NULL != p && 0 == strcmp("/usr/include", p));
+
+    p = opal_cmd_line_get_param(&cmd, "include", 1, 0);
+    test_verify("include instance 1 == '/opt/include'",
+                NULL != p && 0 == strcmp("/opt/include", p));
+
+    p = opal_cmd_line_get_param(&cmd, "include", 2, 0);
+    test_verify("include instance 2 == '/home/user/include'",
+                NULL != p && 0 == strcmp("/home/user/include", p));
+
+    /* Instance 3 (zero-indexed 4th) does not exist */
+    p = opal_cmd_line_get_param(&cmd, "include", 3, 0);
+    test_verify("include instance 3 == NULL (doesn't exist)",
+                NULL == p);
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_single_dash_name -- single-dash multi-char name (e.g., -np)
+ * ----------------------------------------------------------------------- */
+static void test_parse_single_dash_name(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    char *p;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+
+    /* Register a single-dash name "np" (no short, no long) */
+    opal_cmd_line_make_opt3(&cmd, '\0', "np", NULL, 1, "Num procs (compat)");
+    /* Also register a normal long option to keep things interesting */
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+
+    char *args[] = { "mpirun", "-np", "4", "--verbose", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 4, args);
+    test_verify("single-dash name parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("is_taken('np') == true",
+                opal_cmd_line_is_taken(&cmd, "np"));
+    test_verify("is_taken('verbose') == true",
+                opal_cmd_line_is_taken(&cmd, "verbose"));
+
+    p = opal_cmd_line_get_param(&cmd, "np", 0, 0);
+    test_verify("get_param('np',0,0) == '4'",
+                NULL != p && 0 == strcmp("4", p));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_combined_shorts -- "-abc" expands to "-a -b -c" via split_shorts
+ * ----------------------------------------------------------------------- */
+static void test_combined_shorts(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'a', NULL, "all",     0, "Option A");
+    opal_cmd_line_make_opt3(&cmd, 'b', NULL, "batch",   0, "Option B");
+    opal_cmd_line_make_opt3(&cmd, 'c', NULL, "check",   0, "Option C");
+    opal_cmd_line_make_opt3(&cmd, 'd', NULL, "debug",   0, "Debug");
+
+    /* "-abc" should expand to "-a", "-b", "-c" */
+    char *args[] = { "prog", "-abc", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 2, args);
+    test_verify("combined shorts parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("is_taken('a') == true after -abc",
+                opal_cmd_line_is_taken(&cmd, "a"));
+    test_verify("is_taken('b') == true after -abc",
+                opal_cmd_line_is_taken(&cmd, "b"));
+    test_verify("is_taken('c') == true after -abc",
+                opal_cmd_line_is_taken(&cmd, "c"));
+    test_verify("is_taken('d') == false (not in -abc)",
+                !opal_cmd_line_is_taken(&cmd, "d"));
+
+    /* Each flag appears once */
+    test_verify("get_ninsts('a') == 1", 1 == opal_cmd_line_get_ninsts(&cmd, "a"));
+    test_verify("get_ninsts('b') == 1", 1 == opal_cmd_line_get_ninsts(&cmd, "b"));
+    test_verify("get_ninsts('c') == 1", 1 == opal_cmd_line_get_ninsts(&cmd, "c"));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_double_dash_separator -- "--" stops parsing, rest goes to tail
+ * ----------------------------------------------------------------------- */
+static void test_parse_double_dash_separator(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    int tailc;
+    char **tailv;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+    opal_cmd_line_make_opt3(&cmd, 'n', NULL, "numprocs",1, "Num procs");
+
+    /* "--" separates known options from the "tail" arguments */
+    char *args[] = {
+        "prog", "--verbose", "--", "tail1", "tail2", "tail3", NULL
+    };
+    rc = opal_cmd_line_parse(&cmd, false, false, 6, args);
+    test_verify("double-dash parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("is_taken('verbose') == true (before --)",
+                opal_cmd_line_is_taken(&cmd, "verbose"));
+    test_verify("is_taken('numprocs') == false (not in argv)",
+                !opal_cmd_line_is_taken(&cmd, "numprocs"));
+
+    tailc = 0;
+    tailv = NULL;
+    rc = opal_cmd_line_get_tail(&cmd, &tailc, &tailv);
+    test_verify("get_tail returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* tailc = number of real tail tokens (NOT including the NULL sentinel,
+     * despite what the header says about "length including the final NULL
+     * entry" -- the code uses opal_argv_append which counts real tokens
+     * only, so tailc == 3 here.
+     * SUSPECTED BUG: header documents tailc as "length including the final
+     * NULL entry", but the implementation sets tailc = opal_argv_append
+     * count, which excludes the NULL terminator.  We assert the code's
+     * actual behavior (tailc == 3) and verify tailv[tailc] == NULL. */
+    test_verify("tailc == 3 (code counts real tokens, not the NULL sentinel)",
+                3 == tailc);
+    test_verify("tailv is non-NULL", NULL != tailv);
+    if (NULL != tailv) {
+        test_verify("tailv[0] == 'tail1'",
+                    0 == strcmp("tail1", tailv[0]));
+        test_verify("tailv[1] == 'tail2'",
+                    0 == strcmp("tail2", tailv[1]));
+        test_verify("tailv[2] == 'tail3'",
+                    0 == strcmp("tail3", tailv[2]));
+        test_verify("tailv[tailc] == NULL (null-terminated)",
+                    NULL == tailv[tailc]);
+        opal_argv_free(tailv);
+    }
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_unknown_option_error -- unrecognized "-foo" triggers error
+ * ----------------------------------------------------------------------- */
+static void test_parse_unknown_option_error(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    int tailc;
+    char **tailv;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+
+    /* "--unknown" is not registered; parse should fail with OPAL_ERR_SILENT */
+    char *args[] = { "prog", "--verbose", "--unknown", "after", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 4, args);
+    test_verify("unknown option returns OPAL_ERR_SILENT",
+                OPAL_ERR_SILENT == rc);
+
+    /* verbose was seen before the unknown; it should still be recorded */
+    test_verify("is_taken('verbose') == true (seen before unknown)",
+                opal_cmd_line_is_taken(&cmd, "verbose"));
+
+    /* Everything from the unknown token onward goes to the tail */
+    tailc = 0;
+    tailv = NULL;
+    opal_cmd_line_get_tail(&cmd, &tailc, &tailv);
+    test_verify("tail has items after unknown option", tailc >= 1);
+    if (NULL != tailv) {
+        test_verify("first tail token is the unknown option",
+                    0 == strcmp("--unknown", tailv[0]));
+        opal_argv_free(tailv);
+    }
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_missing_param_error -- option that needs N params but gets <N
+ * ----------------------------------------------------------------------- */
+static void test_parse_missing_param_error(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, '\0', NULL, "pair", 2, "Needs two args");
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+
+    /* "--pair" needs 2 args but only 1 follows */
+    char *args[] = { "prog", "--pair", "only_one", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 3, args);
+    test_verify("missing param always returns OPAL_ERR_SILENT",
+                OPAL_ERR_SILENT == rc);
+
+    /* The incomplete option should NOT be recorded as taken */
+    test_verify("is_taken('pair') == false (incomplete, error path)",
+                !opal_cmd_line_is_taken(&cmd, "pair"));
+    test_verify("get_ninsts('pair') == 0", 0 == opal_cmd_line_get_ninsts(&cmd, "pair"));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_parse_ignore_unknown -- ignore_unknown=true, unknown becomes tail
+ * ----------------------------------------------------------------------- */
+static void test_parse_ignore_unknown(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    int tailc;
+    char **tailv;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+
+    /* Unknown plain token (no leading dash) stops parsing when
+     * ignore_unknown=false.  With ignore_unknown=true, it becomes tail. */
+    char *args[] = { "prog", "--verbose", "plain_arg", NULL };
+    rc = opal_cmd_line_parse(&cmd, true, true, 3, args);
+    test_verify("ignore_unknown=true returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    test_verify("is_taken('verbose') == true", opal_cmd_line_is_taken(&cmd, "verbose"));
+
+    tailc = 0;
+    tailv = NULL;
+    opal_cmd_line_get_tail(&cmd, &tailc, &tailv);
+    /* "plain_arg" has no leading dash, so it's an unknown token; it goes to tail */
+    test_verify("plain token is captured in tail", tailc >= 1);
+    if (NULL != tailv) {
+        test_verify("tailv[0] == 'plain_arg'",
+                    0 == strcmp("plain_arg", tailv[0]));
+        opal_argv_free(tailv);
+    }
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_get_argc_and_argv -- opal_cmd_line_get_argc / get_argv
+ * ----------------------------------------------------------------------- */
+static void test_get_argc_and_argv(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+
+    /* Before any parse, argc should be 0 (no argv stored yet) */
+    test_verify("get_argc before parse == 0", 0 == opal_cmd_line_get_argc(&cmd));
+    test_verify("get_argv before parse == NULL", NULL == opal_cmd_line_get_argv(&cmd, 0));
+
+    char *args[] = { "prog", "--verbose", "extra", NULL };
+    rc = opal_cmd_line_parse(&cmd, true, true, 3, args);
+    test_verify("argc/argv parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* After parsing, argc == original argc passed to parse */
+    test_verify("get_argc after parse == 3", 3 == opal_cmd_line_get_argc(&cmd));
+
+    /* get_argv returns the stored copy of the original tokens */
+    test_verify("get_argv(0) == 'prog'",
+                0 == strcmp("prog", opal_cmd_line_get_argv(&cmd, 0)));
+    test_verify("get_argv(1) == '--verbose'",
+                0 == strcmp("--verbose", opal_cmd_line_get_argv(&cmd, 1)));
+    test_verify("get_argv(2) == 'extra'",
+                0 == strcmp("extra", opal_cmd_line_get_argv(&cmd, 2)));
+
+    /* Out-of-range index */
+    test_verify("get_argv(-1) == NULL", NULL == opal_cmd_line_get_argv(&cmd, -1));
+    test_verify("get_argv(3) == NULL (one past end)", NULL == opal_cmd_line_get_argv(&cmd, 3));
+    test_verify("get_argv(999) == NULL", NULL == opal_cmd_line_get_argv(&cmd, 999));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_get_tail -- detailed tail coverage
+ * ----------------------------------------------------------------------- */
+static void test_get_tail(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    int tailc;
+    char **tailv;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+
+    /* No tail expected on a clean parse */
+    char *args1[] = { "prog", "--verbose", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 2, args1);
+    test_verify("clean parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    tailc = 99;
+    tailv = NULL;
+    rc = opal_cmd_line_get_tail(&cmd, &tailc, &tailv);
+    test_verify("get_tail returns OPAL_SUCCESS on clean parse", OPAL_SUCCESS == rc);
+    test_verify("tailc == 0 on clean parse", 0 == tailc);
+    /* opal_argv_copy(NULL) may return NULL; either way free is safe */
+    if (NULL != tailv) {
+        opal_argv_free(tailv);
+    }
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_get_ninsts_unregistered -- get_ninsts on an option not in the handle
+ *
+ * Header prose says: "OPAL_ERR if the command line option was not found
+ * during opal_cmd_line_parse(), or opal_cmd_line_parse() was not invoked
+ * on this handle."
+ *
+ * Code reality: get_ninsts initializes ret=0 and returns 0 when
+ * find_option returns NULL for an unregistered name.  Returning 0 is
+ * internally consistent with the "count including 0" semantics documented
+ * elsewhere in the same function, and is_taken (which calls get_ninsts)
+ * produces the correct false result.  We therefore treat the header prose
+ * as a documentation inaccuracy rather than a code bug, and assert 0.
+ *
+ * DOCUMENTATION DEFECT: header says OPAL_ERR(-1) for an unregistered
+ * option; the implementation returns 0.  Asserting 0 (the sensible value
+ * matching "zero instances found") is correct; the prose should be
+ * updated to match.
+ * ----------------------------------------------------------------------- */
+static void test_get_ninsts_unregistered(void)
+{
+    opal_cmd_line_t cmd;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+
+    char *args[] = { "prog", "--verbose", NULL };
+    opal_cmd_line_parse(&cmd, false, false, 2, args);
+
+    /* Returns 0 (not OPAL_ERROR/-1 as the header prose implies).
+     * DOCUMENTATION DEFECT: see block comment above. */
+    test_verify("get_ninsts on unregistered option returns 0 "
+                "[header prose says OPAL_ERR -- documentation defect, "
+                "0 is the sensible value]",
+                0 == opal_cmd_line_get_ninsts(&cmd, "notregistered"));
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_get_usage_msg -- opal_cmd_line_get_usage_msg returns non-NULL string
+ * ----------------------------------------------------------------------- */
+static void test_get_usage_msg(void)
+{
+    opal_cmd_line_t cmd;
+    char *msg;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose",  0, "Enable verbose output");
+    opal_cmd_line_make_opt3(&cmd, 'n', NULL, "numprocs", 1, "Number of processes");
+    opal_cmd_line_make_opt3(&cmd, '\0', NULL, "hidden", 0, NULL); /* no description */
+
+    msg = opal_cmd_line_get_usage_msg(&cmd);
+    test_verify("get_usage_msg returns non-NULL", NULL != msg);
+    if (NULL != msg) {
+        /* The message should mention at least one of the documented options */
+        test_verify("usage msg contains 'verbose'",
+                    NULL != strstr(msg, "verbose"));
+        test_verify("usage msg contains 'numprocs'",
+                    NULL != strstr(msg, "numprocs"));
+        free(msg);
+    }
+
+    /* Empty handle (no options) should return a non-NULL (possibly empty) string */
+    opal_cmd_line_t empty;
+    OBJ_CONSTRUCT(&empty, opal_cmd_line_t);
+    msg = opal_cmd_line_get_usage_msg(&empty);
+    test_verify("get_usage_msg on empty handle returns non-NULL", NULL != msg);
+    if (NULL != msg) {
+        free(msg);
+    }
+    OBJ_DESTRUCT(&empty);
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_set_dest_variable -- ocl_variable_dest auto-fill via create table
+ * ----------------------------------------------------------------------- */
+static void test_set_dest_variable(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    /* Destinations that get filled by the parser */
+    bool    flag_val  = false;
+    char   *str_val   = NULL;
+    int     int_val   = 0;
+
+    opal_cmd_line_init_t table[] = {
+        /* Boolean flag */
+        { NULL, 'f', NULL, "flag", 0,
+          &flag_val, OPAL_CMD_LINE_TYPE_BOOL,
+          "A boolean flag", OPAL_CMD_LINE_OTYPE_GENERAL },
+
+        /* String option */
+        { NULL, 's', NULL, "str", 1,
+          &str_val, OPAL_CMD_LINE_TYPE_STRING,
+          "A string option", OPAL_CMD_LINE_OTYPE_GENERAL },
+
+        /* Int option */
+        { NULL, 'i', NULL, "ival", 1,
+          &int_val, OPAL_CMD_LINE_TYPE_INT,
+          "An int option", OPAL_CMD_LINE_OTYPE_GENERAL },
+
+        /* Sentinel */
+        { NULL, '\0', NULL, NULL, 0,
+          NULL, OPAL_CMD_LINE_TYPE_NULL, NULL, OPAL_CMD_LINE_OTYPE_NULL }
+    };
+
+    rc = opal_cmd_line_create(&cmd, table);
+    test_verify("create with dest table succeeds", OPAL_SUCCESS == rc);
+
+    char *args[] = { "prog", "--flag", "--str", "hello", "--ival", "42", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 6, args);
+    test_verify("parse with dest variables returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* Bool flag dest set to true (1) */
+    test_verify("bool dest set to true after --flag", flag_val);
+
+    /* String dest set to a copy of the argument */
+    test_verify("str dest non-NULL after --str hello", NULL != str_val);
+    if (NULL != str_val) {
+        test_verify("str dest == 'hello'", 0 == strcmp("hello", str_val));
+        /* set_dest strdup's the value; we free it to avoid a leak */
+        free(str_val);
+        str_val = NULL;
+    }
+
+    /* Int dest set to 42 */
+    test_verify("int dest == 42 after --ival 42", 42 == int_val);
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_set_dest_int_invalid -- set_dest with non-numeric value for INT type
+ *
+ * When an option is registered with OPAL_CMD_LINE_TYPE_INT and the value
+ * supplied on the command line is not a valid integer (e.g. "abc"), set_dest
+ * prints an error message to stderr and returns OPAL_ERR_SILENT, which
+ * propagates out of opal_cmd_line_parse.
+ *
+ * SUSPECTED BUG: In the OPAL_CMD_LINE_TYPE_INT validation error path
+ * (cmd_line.c set_dest), the function prints to stderr and returns
+ * OPAL_ERR_SILENT but does NOT call OBJ_RELEASE(param) before returning —
+ * the param_t allocated during parsing is leaked.  This is an early-return
+ * path that bypasses the normal cleanup.  We cannot assert the leak here
+ * (no portable way to observe it), but we note it for future investigation.
+ * ----------------------------------------------------------------------- */
+static void test_set_dest_int_invalid(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+    int int_val = 0;
+
+    opal_cmd_line_init_t table[] = {
+        { NULL, 'i', NULL, "ival", 1,
+          &int_val, OPAL_CMD_LINE_TYPE_INT,
+          "An int option", OPAL_CMD_LINE_OTYPE_GENERAL },
+        { NULL, '\0', NULL, NULL, 0,
+          NULL, OPAL_CMD_LINE_TYPE_NULL, NULL, OPAL_CMD_LINE_OTYPE_NULL }
+    };
+
+    rc = opal_cmd_line_create(&cmd, table);
+    test_verify("create for int-invalid test succeeds", OPAL_SUCCESS == rc);
+
+    /* "abc" is not a valid integer; set_dest returns OPAL_ERR_SILENT */
+    char *args[] = { "prog", "--ival", "abc", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 3, args);
+    test_verify("parse with non-numeric INT value returns OPAL_ERR_SILENT",
+                OPAL_ERR_SILENT == rc);
+
+    /* int_val must remain at its pre-parse sentinel (0) since set_dest errored */
+    test_verify("int dest unchanged after invalid parse", 0 == int_val);
+
+    OBJ_DESTRUCT(&cmd);
+}
+
+/* -----------------------------------------------------------------------
+ * test_reparse -- calling opal_cmd_line_parse twice on the same handle
+ *                 must erase previous results
+ * ----------------------------------------------------------------------- */
+static void test_reparse(void)
+{
+    opal_cmd_line_t cmd;
+    int rc;
+
+    OBJ_CONSTRUCT(&cmd, opal_cmd_line_t);
+    opal_cmd_line_make_opt3(&cmd, 'v', NULL, "verbose", 0, "Verbose");
+    opal_cmd_line_make_opt3(&cmd, 'd', NULL, "debug",   0, "Debug");
+
+    /* First parse: only verbose */
+    char *args1[] = { "prog", "--verbose", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 2, args1);
+    test_verify("first parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("verbose taken after first parse",
+                opal_cmd_line_is_taken(&cmd, "verbose"));
+    test_verify("debug not taken after first parse",
+                !opal_cmd_line_is_taken(&cmd, "debug"));
+
+    /* Second parse: only debug — previous results must be cleared */
+    char *args2[] = { "prog", "--debug", NULL };
+    rc = opal_cmd_line_parse(&cmd, false, false, 2, args2);
+    test_verify("second parse returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("debug taken after second parse",
+                opal_cmd_line_is_taken(&cmd, "debug"));
+    test_verify("verbose NOT taken after second parse (results erased)",
+                !opal_cmd_line_is_taken(&cmd, "verbose"));
+    test_verify("get_ninsts('verbose') == 0 after second parse",
+                0 == opal_cmd_line_get_ninsts(&cmd, "verbose"));
+
+    OBJ_DESTRUCT(&cmd);
+}
diff --git a/test/util/opal_crc.c b/test/util/opal_crc.c
new file mode 100644
index 00000000000..f50608c27cb
--- /dev/null
+++ b/test/util/opal_crc.c
@@ -0,0 +1,687 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2006 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+#include "opal/util/crc.h"
+
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_csum_partial / opal_csum (unsigned long variant)
+ * ---------------------------------------------------------------------- */
+
+static void test_csum_partial_determinism(void)
+{
+    /* Same input must produce the same output */
+    static const unsigned char buf[16] = {
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
+    };
+    unsigned long plong1 = 0, plong2 = 0;
+    size_t plen1 = 0, plen2 = 0;
+
+    unsigned long c1 = opal_csum_partial(buf, sizeof(buf), &plong1, &plen1);
+    unsigned long c2 = opal_csum_partial(buf, sizeof(buf), &plong2, &plen2);
+
+    test_verify("csum_partial: same input -> same result (c1==c2)", c1 == c2);
+    test_verify("csum_partial: inline helper opal_csum matches",
+                opal_csum(buf, sizeof(buf)) == c1);
+}
+
+static void test_csum_partial_different_inputs(void)
+{
+    static const unsigned char buf_a[8] = {0x01, 0x02, 0x03, 0x04,
+                                           0x05, 0x06, 0x07, 0x08};
+    static const unsigned char buf_b[8] = {0xff, 0xfe, 0xfd, 0xfc,
+                                           0xfb, 0xfa, 0xf9, 0xf8};
+    unsigned long plong = 0;
+    size_t plen = 0;
+
+    unsigned long ca = opal_csum_partial(buf_a, sizeof(buf_a), &plong, &plen);
+    plong = 0;
+    plen = 0;
+    unsigned long cb = opal_csum_partial(buf_b, sizeof(buf_b), &plong, &plen);
+
+    test_verify("csum_partial: different inputs give different checksums", ca != cb);
+}
+
+static void test_csum_partial_zero_buf(void)
+{
+    /* All-zero buffer: checksum must be 0 */
+    static const unsigned char zeros[32] = {0};
+    unsigned long plong = 0;
+    size_t plen = 0;
+
+    unsigned long c = opal_csum_partial(zeros, sizeof(zeros), &plong, &plen);
+    test_verify("csum_partial: all-zeros buffer -> csum is 0", 0 == c);
+}
+
+static void test_csum_partial_nonaligned_length(void)
+{
+    /* Non-word-aligned length (5 bytes): two calls must match opal_csum */
+    static const unsigned char buf[5] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE};
+    unsigned long plong = 0;
+    size_t plen = 0;
+
+    unsigned long c_partial = opal_csum_partial(buf, 5, &plong, &plen);
+    unsigned long c_inline = opal_csum(buf, 5);
+
+    test_verify("csum_partial: 5-byte (non-aligned) matches opal_csum", c_partial == c_inline);
+}
+
+static void test_csum_partial_incremental(void)
+{
+    /*
+     * Incremental: two partial calls over [A|B] must equal one call over [AB].
+     * The partial accumulator state is threaded between calls.
+     *
+     * We split a 20-byte buffer at byte 7 (non-word-aligned boundary).
+     */
+    static const unsigned char full[20] = {
+        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+        0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00,
+        0x12, 0x34, 0x56, 0x78
+    };
+    const size_t split = 7;
+
+    /* Single call over all 20 bytes */
+    unsigned long plong0 = 0;
+    size_t plen0 = 0;
+    unsigned long c_full = opal_csum_partial(full, sizeof(full), &plong0, &plen0);
+
+    /* Two incremental calls */
+    unsigned long plong_inc = 0;
+    size_t plen_inc = 0;
+    unsigned long c1 = opal_csum_partial(full, split, &plong_inc, &plen_inc);
+    unsigned long c2 = opal_csum_partial(full + split, sizeof(full) - split,
+                                         &plong_inc, &plen_inc);
+    unsigned long c_inc = c1 + c2;
+
+    test_verify("csum_partial: incremental over [0..7) + [7..20) == single over [0..20)",
+                c_inc == c_full);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_uicsum_partial / opal_uicsum (unsigned int variant)
+ * ---------------------------------------------------------------------- */
+
+static void test_uicsum_partial_determinism(void)
+{
+    static const unsigned char buf[16] = {
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
+    };
+    unsigned int pint1 = 0, pint2 = 0;
+    size_t plen1 = 0, plen2 = 0;
+
+    unsigned int c1 = opal_uicsum_partial(buf, sizeof(buf), &pint1, &plen1);
+    unsigned int c2 = opal_uicsum_partial(buf, sizeof(buf), &pint2, &plen2);
+
+    test_verify("uicsum_partial: determinism (c1==c2)", c1 == c2);
+    test_verify("uicsum_partial: inline opal_uicsum matches",
+                opal_uicsum(buf, sizeof(buf)) == c1);
+}
+
+static void test_uicsum_partial_zero_buf(void)
+{
+    static const unsigned char zeros[32] = {0};
+    unsigned int pint = 0;
+    size_t plen = 0;
+
+    unsigned int c = opal_uicsum_partial(zeros, sizeof(zeros), &pint, &plen);
+    test_verify("uicsum_partial: all-zeros buffer -> csum is 0", 0u == c);
+}
+
+static void test_uicsum_partial_nonaligned(void)
+{
+    /* 3-byte buffer: non-int-aligned */
+    static const unsigned char buf[3] = {0x01, 0x02, 0x03};
+    unsigned int pint = 0;
+    size_t plen = 0;
+
+    unsigned int c_partial = opal_uicsum_partial(buf, 3, &pint, &plen);
+    unsigned int c_inline  = opal_uicsum(buf, 3);
+
+    test_verify("uicsum_partial: 3-byte non-aligned matches opal_uicsum",
+                c_partial == c_inline);
+}
+
+static void test_uicsum_partial_incremental(void)
+{
+    /*
+     * Split a 20-byte buffer at a 5-byte boundary (non-int-aligned).
+     */
+    static const unsigned char full[20] = {
+        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+        0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00,
+        0x12, 0x34, 0x56, 0x78
+    };
+    const size_t split = 5;
+
+    unsigned int pint0 = 0;
+    size_t plen0 = 0;
+    unsigned int c_full = opal_uicsum_partial(full, sizeof(full), &pint0, &plen0);
+
+    unsigned int pint_inc = 0;
+    size_t plen_inc = 0;
+    unsigned int c1 = opal_uicsum_partial(full, split, &pint_inc, &plen_inc);
+    unsigned int c2 = opal_uicsum_partial(full + split, sizeof(full) - split,
+                                          &pint_inc, &plen_inc);
+    unsigned int c_inc = c1 + c2;
+
+    test_verify("uicsum_partial: incremental [0..5)+[5..20) == single [0..20)",
+                c_inc == c_full);
+}
+
+static void test_uicsum_partial_different_inputs(void)
+{
+    static const unsigned char a[8] = {0xAA, 0xBB, 0xCC, 0xDD,
+                                       0x11, 0x22, 0x33, 0x44};
+    static const unsigned char b[8] = {0x00, 0x01, 0x02, 0x03,
+                                       0x04, 0x05, 0x06, 0x07};
+    unsigned int pint = 0;
+    size_t plen = 0;
+
+    unsigned int ca = opal_uicsum_partial(a, sizeof(a), &pint, &plen);
+    pint = 0;
+    plen = 0;
+    unsigned int cb = opal_uicsum_partial(b, sizeof(b), &pint, &plen);
+
+    test_verify("uicsum_partial: different inputs -> different checksums", ca != cb);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_bcopy_csum_partial (unsigned long variant)
+ * ---------------------------------------------------------------------- */
+
+static void test_bcopy_csum_partial_copy(void)
+{
+    /* Verify that the bcopy variant actually copies src -> dst */
+    static const unsigned char src[16] = {
+        0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE,
+        0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
+    };
+    unsigned char dst[16];
+    unsigned long plong = 0;
+    size_t plen = 0;
+
+    memset(dst, 0, sizeof(dst));
+    opal_bcopy_csum_partial(src, dst, sizeof(src), sizeof(src), &plong, &plen);
+
+    test_verify("bcopy_csum_partial: destination contains copy of source",
+                0 == memcmp(src, dst, sizeof(src)));
+}
+
+static void test_bcopy_csum_partial_matches_csum(void)
+{
+    /*
+     * The checksum returned by bcopy_csum_partial must equal the one
+     * returned by csum_partial over the same data.
+     */
+    static const unsigned char src[16] = {
+        0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80,
+        0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0x00
+    };
+    unsigned char dst[16];
+    unsigned long plong_bc = 0, plong_cs = 0;
+    size_t plen_bc = 0, plen_cs = 0;
+
+    unsigned long c_bc = opal_bcopy_csum_partial(src, dst, sizeof(src), sizeof(src),
+                                                 &plong_bc, &plen_bc);
+    unsigned long c_cs = opal_csum_partial(src, sizeof(src), &plong_cs, &plen_cs);
+
+    test_verify("bcopy_csum_partial: checksum matches csum_partial", c_bc == c_cs);
+}
+
+static void test_bcopy_csum_partial_nonaligned(void)
+{
+    /* 7-byte buffer: exercises the partial-word residue path */
+    static const unsigned char src[7] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};
+    unsigned char dst[7];
+    unsigned long plong_bc = 0, plong_cs = 0;
+    size_t plen_bc = 0, plen_cs = 0;
+
+    memset(dst, 0, sizeof(dst));
+    unsigned long c_bc = opal_bcopy_csum_partial(src, dst, sizeof(src), sizeof(src),
+                                                 &plong_bc, &plen_bc);
+    unsigned long c_cs = opal_csum_partial(src, sizeof(src), &plong_cs, &plen_cs);
+
+    test_verify("bcopy_csum_partial 7-byte: dst is copy of src",
+                0 == memcmp(src, dst, sizeof(src)));
+    test_verify("bcopy_csum_partial 7-byte: checksum matches csum_partial", c_bc == c_cs);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_bcopy_uicsum_partial (unsigned int variant)
+ * ---------------------------------------------------------------------- */
+
+static void test_bcopy_uicsum_partial_copy(void)
+{
+    static const unsigned char src[12] = {
+        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+        0x99, 0xAA, 0xBB, 0xCC
+    };
+    unsigned char dst[12];
+    unsigned int pint = 0;
+    size_t plen = 0;
+
+    memset(dst, 0, sizeof(dst));
+    opal_bcopy_uicsum_partial(src, dst, sizeof(src), sizeof(src), &pint, &plen);
+
+    test_verify("bcopy_uicsum_partial: dst is copy of src",
+                0 == memcmp(src, dst, sizeof(src)));
+}
+
+static void test_bcopy_uicsum_partial_matches_uicsum(void)
+{
+    static const unsigned char src[12] = {
+        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+        0x99, 0xAA, 0xBB, 0xCC
+    };
+    unsigned char dst[12];
+    unsigned int pint_bc = 0, pint_ui = 0;
+    size_t plen_bc = 0, plen_ui = 0;
+
+    unsigned int c_bc = opal_bcopy_uicsum_partial(src, dst, sizeof(src), sizeof(src),
+                                                   &pint_bc, &plen_bc);
+    unsigned int c_ui = opal_uicsum_partial(src, sizeof(src), &pint_ui, &plen_ui);
+
+    test_verify("bcopy_uicsum_partial: checksum matches uicsum_partial", c_bc == c_ui);
+}
+
+static void test_bcopy_uicsum_partial_nonaligned(void)
+{
+    /* 5-byte: non-int-aligned */
+    static const unsigned char src[5] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE};
+    unsigned char dst[5];
+    unsigned int pint_bc = 0, pint_ui = 0;
+    size_t plen_bc = 0, plen_ui = 0;
+
+    memset(dst, 0, sizeof(dst));
+    unsigned int c_bc = opal_bcopy_uicsum_partial(src, dst, sizeof(src), sizeof(src),
+                                                   &pint_bc, &plen_bc);
+    unsigned int c_ui = opal_uicsum_partial(src, sizeof(src), &pint_ui, &plen_ui);
+
+    test_verify("bcopy_uicsum_partial 5-byte: dst is copy of src",
+                0 == memcmp(src, dst, sizeof(src)));
+    test_verify("bcopy_uicsum_partial 5-byte: checksum matches uicsum_partial", c_bc == c_ui);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_uicrc_partial / opal_uicrc
+ * ---------------------------------------------------------------------- */
+
+static void test_uicrc_partial_table_init(void)
+{
+    /*
+     * Calling opal_initialize_crc_table explicitly then opal_uicrc_partial
+     * must produce the same result as calling opal_uicrc_partial cold (which
+     * will auto-init the table).
+     */
+    opal_initialize_crc_table();
+    static const unsigned char buf[8] = {0x01, 0x02, 0x03, 0x04,
+                                         0x05, 0x06, 0x07, 0x08};
+    unsigned int crc1 = opal_uicrc_partial(buf, sizeof(buf), CRC_INITIAL_REGISTER);
+    unsigned int crc2 = opal_uicrc(buf, sizeof(buf));
+
+    test_verify("uicrc: explicit table init matches inline opal_uicrc", crc1 == crc2);
+}
+
+static void test_uicrc_partial_determinism(void)
+{
+    static const unsigned char buf[16] = {
+        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+        0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70
+    };
+
+    unsigned int c1 = opal_uicrc(buf, sizeof(buf));
+    unsigned int c2 = opal_uicrc(buf, sizeof(buf));
+
+    test_verify("uicrc: determinism (c1==c2)", c1 == c2);
+}
+
+static void test_uicrc_partial_different_inputs(void)
+{
+    static const unsigned char a[4] = {0x01, 0x02, 0x03, 0x04};
+    static const unsigned char b[4] = {0x05, 0x06, 0x07, 0x08};
+
+    unsigned int ca = opal_uicrc(a, sizeof(a));
+    unsigned int cb = opal_uicrc(b, sizeof(b));
+
+    test_verify("uicrc: different inputs -> different CRCs", ca != cb);
+}
+
+static void test_uicrc_partial_nonaligned(void)
+{
+    /* 3-byte (non-int-aligned): exercises the unaligned source path */
+    static const unsigned char buf[3] = {0xDE, 0xAD, 0xBE};
+
+    unsigned int c1 = opal_uicrc(buf, 3);
+    unsigned int c2 = opal_uicrc(buf, 3);
+
+    test_verify("uicrc: 3-byte non-aligned, deterministic", c1 == c2);
+}
+
+static void test_uicrc_partial_incremental(void)
+{
+    /*
+     * CRC chaining: crc(A || B) via two partial calls must equal
+     * opal_uicrc over the concatenated buffer.
+     *
+     * opal_uicrc_partial(B, partial_crc) takes the running CRC as seed.
+     */
+    static const unsigned char full[16] = {
+        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+        0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00
+    };
+    const size_t split = 7;   /* non-int-aligned split */
+
+    unsigned int c_full = opal_uicrc(full, sizeof(full));
+
+    /* chain: first call seeds with CRC_INITIAL_REGISTER */
+    unsigned int crc_mid = opal_uicrc_partial(full, split, CRC_INITIAL_REGISTER);
+    unsigned int c_chain = opal_uicrc_partial(full + split, sizeof(full) - split, crc_mid);
+
+    test_verify("uicrc_partial: chained [0..7)+[7..16) == single [0..16)",
+                c_chain == c_full);
+}
+
+static void test_uicrc_partial_all_zeros(void)
+{
+    /* All-zero buffer: CRC must be non-initial-register (CRC has diffusion) */
+    static const unsigned char zeros[8] = {0};
+    unsigned int crc = opal_uicrc(zeros, sizeof(zeros));
+
+    /* CRC of zeros with standard polynomial is not CRC_INITIAL_REGISTER */
+    test_verify("uicrc: CRC of all-zeros differs from initial register",
+                CRC_INITIAL_REGISTER != crc);
+}
+
+static void test_uicrc_partial_large_aligned(void)
+{
+    /* 64-byte (word-aligned) buffer: exercises the fast int-aligned path */
+    unsigned char buf[64];
+    unsigned int i;
+    for (i = 0; i < 64; i++) {
+        buf[i] = (unsigned char) (i & 0xff);
+    }
+
+    unsigned int c1 = opal_uicrc(buf, sizeof(buf));
+    unsigned int c2 = opal_uicrc(buf, sizeof(buf));
+
+    test_verify("uicrc: 64-byte aligned buffer, deterministic", c1 == c2);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_bcopy_uicrc_partial
+ * ---------------------------------------------------------------------- */
+
+static void test_bcopy_uicrc_partial_copy(void)
+{
+    static const unsigned char src[16] = {
+        0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE,
+        0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
+    };
+    unsigned char dst[16];
+
+    memset(dst, 0, sizeof(dst));
+    opal_bcopy_uicrc_partial(src, dst, sizeof(src), sizeof(src), CRC_INITIAL_REGISTER);
+
+    test_verify("bcopy_uicrc_partial: dst is copy of src",
+                0 == memcmp(src, dst, sizeof(src)));
+}
+
+static void test_bcopy_uicrc_partial_matches_uicrc(void)
+{
+    static const unsigned char src[16] = {
+        0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80,
+        0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0x00
+    };
+    unsigned char dst[16];
+
+    unsigned int c_bc  = opal_bcopy_uicrc_partial(src, dst, sizeof(src), sizeof(src),
+                                                   CRC_INITIAL_REGISTER);
+    unsigned int c_crc = opal_uicrc(src, sizeof(src));
+
+    test_verify("bcopy_uicrc_partial: checksum matches opal_uicrc", c_bc == c_crc);
+}
+
+static void test_bcopy_uicrc_partial_nonaligned(void)
+{
+    /* 5-byte: exercises the non-int-aligned copy path */
+    static const unsigned char src[5] = {0x01, 0x02, 0x03, 0x04, 0x05};
+    unsigned char dst[5];
+
+    memset(dst, 0, sizeof(dst));
+    unsigned int c_bc  = opal_bcopy_uicrc_partial(src, dst, sizeof(src), sizeof(src),
+                                                   CRC_INITIAL_REGISTER);
+    unsigned int c_crc = opal_uicrc(src, sizeof(src));
+
+    test_verify("bcopy_uicrc_partial 5-byte: dst is copy of src",
+                0 == memcmp(src, dst, sizeof(src)));
+    test_verify("bcopy_uicrc_partial 5-byte: checksum matches opal_uicrc", c_bc == c_crc);
+}
+
+static void test_bcopy_uicrc_partial_inline_helper(void)
+{
+    /* opal_bcopy_uicrc is a static inline wrapping bcopy_uicrc_partial */
+    static const unsigned char src[8] = {0xAA, 0xBB, 0xCC, 0xDD,
+                                         0x11, 0x22, 0x33, 0x44};
+    unsigned char dst1[8], dst2[8];
+
+    memset(dst1, 0, sizeof(dst1));
+    memset(dst2, 0, sizeof(dst2));
+
+    unsigned int c1 = opal_bcopy_uicrc(src, dst1, sizeof(src), sizeof(src));
+    unsigned int c2 = opal_uicrc(src, sizeof(src));
+
+    test_verify("bcopy_uicrc (inline helper): checksum matches opal_uicrc", c1 == c2);
+    test_verify("bcopy_uicrc (inline helper): dst is copy of src",
+                0 == memcmp(src, dst1, sizeof(src)));
+}
+
+static void test_bcopy_uicrc_partial_crconly_residue(void)
+{
+    /*
+     * Test crclen > copylen: the function must CRC crclen bytes total
+     * while only copying copylen bytes from source.
+     *
+     * Use a large source buffer; copy only first half, but CRC the full buf.
+     */
+    static const unsigned char src[16] = {
+        0xA1, 0xB2, 0xC3, 0xD4, 0xE5, 0xF6, 0x07, 0x18,
+        0x29, 0x3A, 0x4B, 0x5C, 0x6D, 0x7E, 0x8F, 0x90
+    };
+    unsigned char dst[16];
+    const size_t copylen = 8;
+    const size_t crclen  = 16;
+
+    memset(dst, 0, sizeof(dst));
+    /* Copy 8 bytes, CRC all 16 */
+    unsigned int c_partial = opal_bcopy_uicrc_partial(src, dst, copylen, crclen,
+                                                       CRC_INITIAL_REGISTER);
+    /* CRC of all 16 bytes via plain crc */
+    unsigned int c_full    = opal_uicrc(src, crclen);
+
+    test_verify("bcopy_uicrc_partial (crclen>copylen): only copylen bytes copied",
+                0 == memcmp(src, dst, copylen));
+    test_verify("bcopy_uicrc_partial (crclen>copylen): CRC covers full crclen",
+                c_partial == c_full);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: csum16 (inline in header -- test via the macro and direct call)
+ * ---------------------------------------------------------------------- */
+
+static void test_csum16_basic(void)
+{
+    /*
+     * opal_csum16 is a static inline computing a 16-bit Internet-style
+     * checksum (sum of 16-bit words, fold carry).
+     * For an all-zero buffer the checksum is 0.
+     */
+    static const unsigned char zeros[8] = {0};
+    uint16_t c = opal_csum16(zeros, sizeof(zeros));
+    test_verify("csum16: all-zeros -> 0", 0u == c);
+}
+
+static void test_csum16_determinism(void)
+{
+    static const unsigned char buf[10] = {
+        0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05
+    };
+    uint16_t c1 = opal_csum16(buf, sizeof(buf));
+    uint16_t c2 = opal_csum16(buf, sizeof(buf));
+    test_verify("csum16: determinism (c1==c2)", c1 == c2);
+}
+
+static void test_csum16_different_inputs(void)
+{
+    static const unsigned char a[4] = {0x00, 0x01, 0x00, 0x02};
+    static const unsigned char b[4] = {0x00, 0x03, 0x00, 0x04};
+    uint16_t ca = opal_csum16(a, sizeof(a));
+    uint16_t cb = opal_csum16(b, sizeof(b));
+    test_verify("csum16: different inputs -> different checksums", ca != cb);
+}
+
+static void test_csum16_known_value(void)
+{
+    /*
+     * opal_csum16 sums native-endian uint16_t words and returns the
+     * carry-folded sum (not the one's complement -- see test_csum16_basic,
+     * where an all-zero buffer checksums to 0).  A buffer holding a single
+     * host-order uint16_t value therefore checksums to that exact value:
+     * one word is read, and a value <= 0xFFFF produces no carry to fold.
+     * Building the buffer from a uint16_t via memcpy makes the expected
+     * result endianness-portable.
+     */
+    const uint16_t expected = 0x1234;
+    unsigned char buf[sizeof(uint16_t)];
+    uint16_t c;
+
+    memcpy(buf, &expected, sizeof(expected));
+    c = opal_csum16(buf, sizeof(buf));
+    test_verify("csum16: single host-order uint16_t checksums to its own value",
+                expected == c);
+}
+
+static void test_csum16_odd_length(void)
+{
+    /* Odd length exercises the "leftover byte" path */
+    static const unsigned char buf[3] = {0x01, 0x02, 0x03};
+    uint16_t c1 = opal_csum16(buf, sizeof(buf));
+    uint16_t c2 = opal_csum16(buf, sizeof(buf));
+    test_verify("csum16: odd-length (3) deterministic", c1 == c2);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: OPAL_CSUM / OPAL_CSUM_PARTIAL macros
+ * ---------------------------------------------------------------------- */
+
+static void test_macro_csum(void)
+{
+    static const unsigned char buf[8] = {0xDE, 0xAD, 0xBE, 0xEF,
+                                         0xCA, 0xFE, 0xBA, 0xBE};
+    unsigned int pint = 0;
+    size_t plen = 0;
+
+    unsigned int c_macro = OPAL_CSUM(buf, sizeof(buf));
+    unsigned int c_direct = opal_uicsum(buf, sizeof(buf));
+
+    test_verify("OPAL_CSUM macro matches opal_uicsum", c_macro == c_direct);
+
+    unsigned int c_partial_macro =
+        OPAL_CSUM_PARTIAL(buf, sizeof(buf), &pint, &plen);
+    pint = 0;
+    plen = 0;
+    unsigned int c_partial_direct =
+        opal_uicsum_partial(buf, sizeof(buf), &pint, &plen);
+
+    test_verify("OPAL_CSUM_PARTIAL macro matches opal_uicsum_partial",
+                c_partial_macro == c_partial_direct);
+}
+
+/* -----------------------------------------------------------------------
+ * main
+ * ---------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_crc");
+
+    /* opal_csum_partial / opal_csum */
+    test_csum_partial_determinism();
+    test_csum_partial_different_inputs();
+    test_csum_partial_zero_buf();
+    test_csum_partial_nonaligned_length();
+    test_csum_partial_incremental();
+
+    /* opal_uicsum_partial / opal_uicsum */
+    test_uicsum_partial_determinism();
+    test_uicsum_partial_zero_buf();
+    test_uicsum_partial_nonaligned();
+    test_uicsum_partial_incremental();
+    test_uicsum_partial_different_inputs();
+
+    /* opal_bcopy_csum_partial */
+    test_bcopy_csum_partial_copy();
+    test_bcopy_csum_partial_matches_csum();
+    test_bcopy_csum_partial_nonaligned();
+
+    /* opal_bcopy_uicsum_partial */
+    test_bcopy_uicsum_partial_copy();
+    test_bcopy_uicsum_partial_matches_uicsum();
+    test_bcopy_uicsum_partial_nonaligned();
+
+    /* opal_uicrc_partial / opal_uicrc (CRC32) */
+    test_uicrc_partial_table_init();
+    test_uicrc_partial_determinism();
+    test_uicrc_partial_different_inputs();
+    test_uicrc_partial_nonaligned();
+    test_uicrc_partial_incremental();
+    test_uicrc_partial_all_zeros();
+    test_uicrc_partial_large_aligned();
+
+    /* opal_bcopy_uicrc_partial */
+    test_bcopy_uicrc_partial_copy();
+    test_bcopy_uicrc_partial_matches_uicrc();
+    test_bcopy_uicrc_partial_nonaligned();
+    test_bcopy_uicrc_partial_inline_helper();
+    test_bcopy_uicrc_partial_crconly_residue();
+
+    /* opal_csum16 */
+    test_csum16_basic();
+    test_csum16_determinism();
+    test_csum16_different_inputs();
+    test_csum16_known_value();
+    test_csum16_odd_length();
+
+    /* macros */
+    test_macro_csum();
+
+    return test_finalize();
+}
diff --git a/test/util/opal_environ.c b/test/util/opal_environ.c
new file mode 100644
index 00000000000..2b57c461cd7
--- /dev/null
+++ b/test/util/opal_environ.c
@@ -0,0 +1,278 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+#include "support.h"
+#include "opal/util/opal_environ.h"
+#include "opal/util/argv.h"
+#include "opal/constants.h"
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------------------------------------------------------ */
+/* helpers                                                              */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Return the value portion of a "NAME=value" entry in an env array,
+ * or NULL if not found.
+ */
+static const char *env_lookup(char **env, const char *name)
+{
+    size_t nlen;
+    int i;
+
+    if (NULL == env || NULL == name) {
+        return NULL;
+    }
+    nlen = strlen(name);
+    for (i = 0; NULL != env[i]; ++i) {
+        if (0 == strncmp(env[i], name, nlen) && '=' == env[i][nlen]) {
+            return env[i] + nlen + 1;
+        }
+    }
+    return NULL;
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_setenv                                                          */
+/* ------------------------------------------------------------------ */
+
+static void test_setenv(void)
+{
+    char **env = NULL;
+    int rc;
+    const char *val;
+
+    /* Add to a NULL *env (env pointer itself is non-NULL, *env is NULL) */
+    rc = opal_setenv("FOO", "bar", true, &env);
+    test_verify("setenv into *env==NULL: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("setenv into *env==NULL: env non-NULL", NULL != env);
+    val = env_lookup(env, "FOO");
+    test_verify("setenv into *env==NULL: value stored", NULL != val);
+    test_verify("setenv into *env==NULL: value is 'bar'",
+                NULL != val && 0 == strcmp("bar", val));
+
+    /* Add a second distinct variable */
+    rc = opal_setenv("BAR", "qux", true, &env);
+    test_verify("setenv second var: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("setenv second var: 'qux' stored",
+                0 == strcmp("qux", env_lookup(env, "BAR")));
+    test_verify("setenv second var: FOO still present",
+                0 == strcmp("bar", env_lookup(env, "FOO")));
+
+    /* Overwrite existing variable (overwrite=true) */
+    rc = opal_setenv("FOO", "newval", true, &env);
+    test_verify("setenv overwrite=true: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("setenv overwrite=true: value updated",
+                0 == strcmp("newval", env_lookup(env, "FOO")));
+
+    /* Attempt overwrite with overwrite=false => OPAL_EXISTS, value unchanged */
+    rc = opal_setenv("FOO", "ignored", false, &env);
+    test_verify("setenv overwrite=false: OPAL_EXISTS", OPAL_EXISTS == rc);
+    test_verify("setenv overwrite=false: value unchanged",
+                0 == strcmp("newval", env_lookup(env, "FOO")));
+
+    /* New variable with overwrite=false -- should still append */
+    rc = opal_setenv("NEWVAR", "hello", false, &env);
+    test_verify("setenv new var overwrite=false: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("setenv new var overwrite=false: value stored",
+                0 == strcmp("hello", env_lookup(env, "NEWVAR")));
+
+    /* value==NULL: stores "NAME=" */
+    rc = opal_setenv("NULLVAL", NULL, true, &env);
+    test_verify("setenv NULL value: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    val = env_lookup(env, "NULLVAL");
+    test_verify("setenv NULL value: stored", NULL != val);
+    test_verify("setenv NULL value: empty string",
+                NULL != val && 0 == strcmp("", val));
+
+    /* bozo: NULL env pointer => OPAL_ERR_BAD_PARAM */
+    rc = opal_setenv("X", "y", true, NULL);
+    test_verify("setenv NULL env: OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == rc);
+
+    opal_argv_free(env);
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_unsetenv                                                        */
+/* ------------------------------------------------------------------ */
+
+static void test_unsetenv(void)
+{
+    char **env = NULL;
+    int rc;
+
+    /* Build a small env */
+    opal_setenv("A", "1", true, &env);
+    opal_setenv("B", "2", true, &env);
+    opal_setenv("C", "3", true, &env);
+
+    test_verify("unsetenv initial count == 3", 3 == opal_argv_count(env));
+
+    /* Remove a variable that exists */
+    rc = opal_unsetenv("B", &env);
+    test_verify("unsetenv existing: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("unsetenv existing: count decremented", 2 == opal_argv_count(env));
+    test_verify("unsetenv existing: B gone", NULL == env_lookup(env, "B"));
+    test_verify("unsetenv existing: A still there",
+                0 == strcmp("1", env_lookup(env, "A")));
+    test_verify("unsetenv existing: C still there",
+                0 == strcmp("3", env_lookup(env, "C")));
+
+    /* Remove a variable that does NOT exist => OPAL_ERR_NOT_FOUND */
+    rc = opal_unsetenv("NOTPRESENT", &env);
+    test_verify("unsetenv not found: OPAL_ERR_NOT_FOUND",
+                OPAL_ERR_NOT_FOUND == rc);
+    test_verify("unsetenv not found: count unchanged", 2 == opal_argv_count(env));
+
+    /* Remove first element */
+    rc = opal_unsetenv("A", &env);
+    test_verify("unsetenv first: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("unsetenv first: count == 1", 1 == opal_argv_count(env));
+    test_verify("unsetenv first: A gone", NULL == env_lookup(env, "A"));
+
+    /* Remove last element */
+    rc = opal_unsetenv("C", &env);
+    test_verify("unsetenv last: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("unsetenv last: count == 0", 0 == opal_argv_count(env));
+
+    /* unsetenv on empty env (NULL *env) => OPAL_SUCCESS */
+    {
+        char **empty = NULL;
+        rc = opal_unsetenv("X", &empty);
+        test_verify("unsetenv on NULL env: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    }
+
+    opal_argv_free(env);
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_environ_merge                                                   */
+/* ------------------------------------------------------------------ */
+
+static void test_environ_merge(void)
+{
+    char **minor;
+    char **major;
+    char **merged;
+
+    /* both NULL => NULL */
+    merged = opal_environ_merge(NULL, NULL);
+    test_verify("merge(NULL,NULL): NULL", NULL == merged);
+
+    /* minor NULL: result is copy of major */
+    major = NULL;
+    opal_setenv("X", "1", true, &major);
+    opal_setenv("Y", "2", true, &major);
+    merged = opal_environ_merge(NULL, major);
+    test_verify("merge(NULL,major): non-NULL", NULL != merged);
+    test_verify("merge(NULL,major): count == 2", 2 == opal_argv_count(merged));
+    test_verify("merge(NULL,major): X=1",
+                0 == strcmp("1", env_lookup(merged, "X")));
+    test_verify("merge(NULL,major): Y=2",
+                0 == strcmp("2", env_lookup(merged, "Y")));
+    opal_argv_free(merged);
+    opal_argv_free(major);
+
+    /* major NULL: result is copy of minor */
+    minor = NULL;
+    opal_setenv("A", "10", true, &minor);
+    opal_setenv("B", "20", true, &minor);
+    merged = opal_environ_merge(minor, NULL);
+    test_verify("merge(minor,NULL): non-NULL", NULL != merged);
+    test_verify("merge(minor,NULL): count == 2", 2 == opal_argv_count(merged));
+    test_verify("merge(minor,NULL): A=10",
+                0 == strcmp("10", env_lookup(merged, "A")));
+    opal_argv_free(merged);
+    opal_argv_free(minor);
+
+    /* conflict: major wins */
+    minor = NULL;
+    major = NULL;
+    opal_setenv("VAR", "minor_val", true, &minor);
+    opal_setenv("MINOR_ONLY", "only", true, &minor);
+    opal_setenv("VAR", "major_val", true, &major);
+    opal_setenv("MAJOR_ONLY", "monly", true, &major);
+
+    merged = opal_environ_merge(minor, major);
+    test_verify("merge conflict: non-NULL", NULL != merged);
+
+    /* Major wins on VAR */
+    test_verify("merge conflict: VAR == major_val",
+                0 == strcmp("major_val", env_lookup(merged, "VAR")));
+
+    /* Minor-only key should be present in result */
+    test_verify("merge conflict: MINOR_ONLY present",
+                0 == strcmp("only", env_lookup(merged, "MINOR_ONLY")));
+
+    /* Major-only key present */
+    test_verify("merge conflict: MAJOR_ONLY present",
+                0 == strcmp("monly", env_lookup(merged, "MAJOR_ONLY")));
+
+    /* Total count: VAR(1) + MINOR_ONLY(1) + MAJOR_ONLY(1) = 3 */
+    test_verify("merge conflict: count == 3", 3 == opal_argv_count(merged));
+
+    opal_argv_free(merged);
+    opal_argv_free(minor);
+    opal_argv_free(major);
+
+    /* merge disjoint sets */
+    minor = NULL;
+    major = NULL;
+    opal_setenv("M1", "a", true, &minor);
+    opal_setenv("M2", "b", true, &minor);
+    opal_setenv("J1", "c", true, &major);
+    opal_setenv("J2", "d", true, &major);
+
+    merged = opal_environ_merge(minor, major);
+    test_verify("merge disjoint: count == 4", 4 == opal_argv_count(merged));
+    test_verify("merge disjoint: M1=a",
+                0 == strcmp("a", env_lookup(merged, "M1")));
+    test_verify("merge disjoint: M2=b",
+                0 == strcmp("b", env_lookup(merged, "M2")));
+    test_verify("merge disjoint: J1=c",
+                0 == strcmp("c", env_lookup(merged, "J1")));
+    test_verify("merge disjoint: J2=d",
+                0 == strcmp("d", env_lookup(merged, "J2")));
+
+    opal_argv_free(merged);
+    opal_argv_free(minor);
+    opal_argv_free(major);
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_environ");
+
+    test_setenv();
+    test_unsetenv();
+    test_environ_merge();
+
+    return test_finalize();
+}
diff --git a/test/util/opal_error.c b/test/util/opal_error.c
index c54743c165a..f1657a5b730 100644
--- a/test/util/opal_error.c
+++ b/test/util/opal_error.c
@@ -2,14 +2,14 @@
  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
  *                         University Research and Technology
  *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
- * Copyright (c) 2024      Jeffrey M. Squyres.  All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -17,73 +17,304 @@
  * $HEADER$
  */
 
-#include "ompi_config.h"
+/*
+ * Unit tests for opal/util/error.c.
+ *
+ * Tests: opal_strerror, opal_strerror_r, opal_perror,
+ *        opal_error_register.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op.
+ * All verification must go through test_verify().
+ *
+ * Implementation note on opal_strerror(OPAL_SUCCESS):
+ *   The OPAL error table is registered with err_base = OPAL_ERR_BASE (0)
+ *   and err_max = OPAL_ERR_MAX (-100).  opal_strerror_int() only invokes a
+ *   converter when (errnum < err_base && err_max < errnum), i.e. strictly
+ *   between -100 and 0.  OPAL_SUCCESS == 0 fails that range (0 < 0 is
+ *   false), so no converter runs.  opal_strerror_int() therefore defaults
+ *   to OPAL_ERROR for such codes (this is the fix in opal/util/error.c;
+ *   it previously defaulted to OPAL_SUCCESS and left *str == NULL).  Since
+ *   the result is now != OPAL_SUCCESS, opal_strerror() takes its
+ *   unknown-error path and returns a non-NULL "Unknown error: 0" string
+ *   rather than NULL.  The tests below assert that non-NULL result.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/error.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
 
+#include <errno.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#ifdef HAVE_SYS_PARAM_H
-#    include <sys/param.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-#    include <netinet/in.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#    include <unistd.h>
-#endif
-#ifdef HAVE_NETDB_H
-#    include <netdb.h>
-#endif
-#include <errno.h>
 
-#include "opal/constants.h"
-#include "opal/runtime/opal.h"
-#include "opal/util/error.h"
-#include "orte/constants.h"
+/* ------------------------------------------------------------------ */
+/* helpers                                                             */
+/* ------------------------------------------------------------------ */
 
-int main(int argc, char *argv[])
+/* Converter used by test_error_register(). */
+#define MY_ERR_BASE (-2000)
+#define MY_ERR_FOO  (-2001)
+#define MY_ERR_BAR  (-2002)
+#define MY_ERR_MAX  (-2010)
+
+static int my_converter(int errnum, const char **str)
+{
+    switch (errnum) {
+    case MY_ERR_FOO:
+        *str = "custom foo error";
+        return OPAL_SUCCESS;
+    case MY_ERR_BAR:
+        *str = "custom bar error";
+        return OPAL_SUCCESS;
+    default:
+        *str = NULL;
+        return OPAL_ERROR;
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_strerror                                                       */
+/* ------------------------------------------------------------------ */
+
+static void test_strerror(void)
 {
-    int i;
-    int errors[] = {
-        OPAL_SUCCESS,
-        OPAL_ERROR,
-        OPAL_ERR_OUT_OF_RESOURCE,
-        OPAL_ERR_NOT_FOUND,
-        OPAL_ERR_BAD_PARAM,
-        OPAL_ERR_MAX + 10, /* bad value */
-        1,                 /* sentinel */
-    };
-    char buf[1024];
-
-    opal_init(&argc, &argv);
-
-    for (i = 0; errors[i] <= 0; ++i) {
-        printf("--> error code: %d\n", errors[i]);
-        opal_perror(errors[i], "perror test");
-        printf("strerror test: %s\n", opal_strerror(errors[i]));
-        opal_strerror_r(errors[i], buf, sizeof(buf));
-        printf("strerror_r test: %s\n", buf);
+    const char *s;
+
+    /*
+     * OPAL_SUCCESS (0) is matched by no registered converter (the OPAL
+     * converter covers the strictly-between (-100, 0) range), so it is
+     * treated as an unknown code and opal_strerror() returns a non-NULL
+     * "Unknown error: 0" string.  (It does not map to "Success": the
+     * opal_err2str converter is never reached for 0.)  The key contract
+     * is that the result is non-NULL so that callers can safely %s it.
+     */
+    s = opal_strerror(OPAL_SUCCESS);
+    test_verify("strerror(OPAL_SUCCESS): non-NULL", NULL != s);
+
+    /* OPAL_ERROR = -1, within range (-100,-1]: should return a non-NULL,
+     * non-empty string. */
+    s = opal_strerror(OPAL_ERROR);
+    test_verify("strerror(OPAL_ERROR): non-NULL", NULL != s);
+    if (NULL != s) {
+        test_verify("strerror(OPAL_ERROR): non-empty", '\0' != s[0]);
+        test_verify("strerror(OPAL_ERROR): equals 'Error'",
+                    0 == strcmp("Error", s));
+    }
+
+    /* OPAL_ERR_OUT_OF_RESOURCE = -2 */
+    s = opal_strerror(OPAL_ERR_OUT_OF_RESOURCE);
+    test_verify("strerror(OPAL_ERR_OUT_OF_RESOURCE): non-NULL", NULL != s);
+    if (NULL != s) {
+        test_verify("strerror(OPAL_ERR_OUT_OF_RESOURCE): equals 'Out of resource'",
+                    0 == strcmp("Out of resource", s));
+    }
+
+    /* OPAL_ERR_NOT_FOUND = -13 */
+    s = opal_strerror(OPAL_ERR_NOT_FOUND);
+    test_verify("strerror(OPAL_ERR_NOT_FOUND): non-NULL", NULL != s);
+    if (NULL != s) {
+        test_verify("strerror(OPAL_ERR_NOT_FOUND): equals 'Not found'",
+                    0 == strcmp("Not found", s));
+    }
+
+    /* OPAL_ERR_BAD_PARAM = -5 */
+    s = opal_strerror(OPAL_ERR_BAD_PARAM);
+    test_verify("strerror(OPAL_ERR_BAD_PARAM): non-NULL", NULL != s);
+    if (NULL != s) {
+        test_verify("strerror(OPAL_ERR_BAD_PARAM): equals 'Bad parameter'",
+                    0 == strcmp("Bad parameter", s));
+    }
+
+    /* Different codes must produce different strings. */
+    {
+        const char *s_error      = opal_strerror(OPAL_ERROR);
+        const char *s_not_found  = opal_strerror(OPAL_ERR_NOT_FOUND);
+        const char *s_bad_param  = opal_strerror(OPAL_ERR_BAD_PARAM);
+        test_verify("strerror: ERROR != NOT_FOUND",
+                    0 != strcmp(s_error, s_not_found));
+        test_verify("strerror: ERROR != BAD_PARAM",
+                    0 != strcmp(s_error, s_bad_param));
     }
 
-    printf("--> error in errno test\n");
+    /* OPAL_ERR_IN_ERRNO: must return strerror(errno) for current errno.
+     * The exact string is system-dependent; just verify non-NULL. */
     errno = EINVAL;
-    opal_perror(OPAL_ERR_IN_ERRNO, "perror test");
+    s = opal_strerror(OPAL_ERR_IN_ERRNO);
+    test_verify("strerror(OPAL_ERR_IN_ERRNO): non-NULL", NULL != s);
+
+    /* A completely unknown code (well outside any registered range)
+     * should return some non-NULL "Unknown error" string. */
+    s = opal_strerror(OPAL_ERR_MAX - 500);
+    test_verify("strerror(unknown code): non-NULL", NULL != s);
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_strerror_r                                                     */
+/* ------------------------------------------------------------------ */
+
+static void test_strerror_r(void)
+{
+    char buf[256];
+    int rc;
+
+    /* OPAL_ERROR must fill the buffer with a non-empty string and
+     * return OPAL_SUCCESS. */
+    buf[0] = '\0';
+    rc = opal_strerror_r(OPAL_ERROR, buf, sizeof(buf));
+    test_verify("strerror_r(OPAL_ERROR): returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    test_verify("strerror_r(OPAL_ERROR): buffer non-empty",
+                '\0' != buf[0]);
+    test_verify("strerror_r(OPAL_ERROR): buffer equals 'Error'",
+                0 == strcmp("Error", buf));
+
+    /* OPAL_ERR_NOT_FOUND */
+    buf[0] = '\0';
+    rc = opal_strerror_r(OPAL_ERR_NOT_FOUND, buf, sizeof(buf));
+    test_verify("strerror_r(OPAL_ERR_NOT_FOUND): returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    test_verify("strerror_r(OPAL_ERR_NOT_FOUND): equals 'Not found'",
+                0 == strcmp("Not found", buf));
+
+    /* OPAL_ERR_BAD_PARAM */
+    buf[0] = '\0';
+    rc = opal_strerror_r(OPAL_ERR_BAD_PARAM, buf, sizeof(buf));
+    test_verify("strerror_r(OPAL_ERR_BAD_PARAM): returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    test_verify("strerror_r(OPAL_ERR_BAD_PARAM): equals 'Bad parameter'",
+                0 == strcmp("Bad parameter", buf));
+
+    /* OPAL_ERR_IN_ERRNO: should copy strerror(errno) into buf. */
     errno = EINVAL;
-    printf("strerror test: %s\n", opal_strerror(OPAL_ERR_IN_ERRNO));
+    buf[0] = '\0';
+    rc = opal_strerror_r(OPAL_ERR_IN_ERRNO, buf, sizeof(buf));
+    test_verify("strerror_r(OPAL_ERR_IN_ERRNO): returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    test_verify("strerror_r(OPAL_ERR_IN_ERRNO): buffer non-empty",
+                '\0' != buf[0]);
+
+    /* Unknown code: should still fill the buffer and return OPAL_SUCCESS. */
+    buf[0] = '\0';
+    rc = opal_strerror_r(OPAL_ERR_MAX - 500, buf, sizeof(buf));
+    test_verify("strerror_r(unknown): returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    test_verify("strerror_r(unknown): buffer non-empty",
+                '\0' != buf[0]);
+
+    /* Multiple calls must not overwrite each other's result (since each
+     * call writes into a caller-supplied buffer). */
+    {
+        char buf1[256];
+        char buf2[256];
+        opal_strerror_r(OPAL_ERROR,         buf1, sizeof(buf1));
+        opal_strerror_r(OPAL_ERR_NOT_FOUND, buf2, sizeof(buf2));
+        test_verify("strerror_r: concurrent buffers independent",
+                    0 != strcmp(buf1, buf2));
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_perror                                                         */
+/* ------------------------------------------------------------------ */
+
+static void test_perror(void)
+{
+    /*
+     * opal_perror() writes to stderr; we cannot easily capture that
+     * output here, so we just verify it does not crash for representative
+     * codes.  A visual inspection of stderr (when running the test) can
+     * be used as a secondary check.
+     */
+    opal_perror(OPAL_SUCCESS,        "perror OPAL_SUCCESS");
+    opal_perror(OPAL_ERROR,          "perror OPAL_ERROR");
+    opal_perror(OPAL_ERR_NOT_FOUND,  "perror OPAL_ERR_NOT_FOUND");
+    opal_perror(OPAL_ERR_BAD_PARAM,  NULL);   /* NULL msg: no prefix */
     errno = EINVAL;
-    opal_strerror_r(OPAL_ERR_IN_ERRNO, buf, sizeof(buf));
-    printf("strerror_r test: %s\n", buf);
+    opal_perror(OPAL_ERR_IN_ERRNO,   "perror OPAL_ERR_IN_ERRNO");
+    opal_perror(OPAL_ERR_MAX - 500,  "perror unknown code");
+    test_verify("perror: did not crash", 1);
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_error_register                                                 */
+/* ------------------------------------------------------------------ */
+
+static void test_error_register(void)
+{
+    int rc;
+    const char *s;
+    char buf[256];
+
+    /*
+     * Register a custom error-code range.  The range must be strictly
+     * wider than any code we intend to look up:
+     *   err_base = MY_ERR_BASE (-2000) -- exclusive upper bound
+     *   err_max  = MY_ERR_MAX  (-2010) -- exclusive lower bound
+     *
+     * opal_strerror_int fires for codes where:
+     *   errnum < err_base  AND  err_max < errnum
+     * i.e. -2010 < errnum < -2000, so MY_ERR_FOO (-2001) and
+     * MY_ERR_BAR (-2002) are both in range.
+     */
+    rc = opal_error_register("MYTEST", MY_ERR_BASE, MY_ERR_MAX, my_converter);
+    test_verify("error_register: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* opal_strerror for MY_ERR_FOO must return the custom string. */
+    s = opal_strerror(MY_ERR_FOO);
+    test_verify("strerror(MY_ERR_FOO): non-NULL", NULL != s);
+    if (NULL != s) {
+        test_verify("strerror(MY_ERR_FOO): equals 'custom foo error'",
+                    0 == strcmp("custom foo error", s));
+    }
 
-    printf("--> orte error test\n");
-    opal_perror(ORTE_ERR_BUFFER, "orte test");
+    /* opal_strerror for MY_ERR_BAR must return the custom string. */
+    s = opal_strerror(MY_ERR_BAR);
+    test_verify("strerror(MY_ERR_BAR): non-NULL", NULL != s);
+    if (NULL != s) {
+        test_verify("strerror(MY_ERR_BAR): equals 'custom bar error'",
+                    0 == strcmp("custom bar error", s));
+    }
+
+    /* opal_strerror_r for MY_ERR_FOO. */
+    buf[0] = '\0';
+    rc = opal_strerror_r(MY_ERR_FOO, buf, sizeof(buf));
+    test_verify("strerror_r(MY_ERR_FOO): OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("strerror_r(MY_ERR_FOO): equals 'custom foo error'",
+                0 == strcmp("custom foo error", buf));
+
+    /* opal_perror for a custom code must not crash. */
+    opal_perror(MY_ERR_FOO, "perror custom MY_ERR_FOO");
+    test_verify("perror custom code: did not crash", 1);
+
+    /* Re-registering the same range+project must succeed (update the
+     * converter) and return OPAL_SUCCESS. */
+    rc = opal_error_register("MYTEST", MY_ERR_BASE, MY_ERR_MAX, my_converter);
+    test_verify("error_register re-register: OPAL_SUCCESS", OPAL_SUCCESS == rc);
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
 
-    printf("--> orte unknown error test\n");
-    opal_perror(ORTE_ERR_MAX + 10, "orte unknown test");
+int main(int argc, char *argv[])
+{
+    int r;
 
-    printf("--> unknown error test\n");
-    opal_perror(ORTE_ERR_MAX - 200, "unknown error");
+    opal_init_util(&argc, &argv);
+    test_init("opal_error");
 
-    opal_finalize();
+    test_strerror();
+    test_strerror_r();
+    test_perror();
+    test_error_register();
 
-    return 0;
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
 }
diff --git a/test/util/opal_fd.c b/test/util/opal_fd.c
new file mode 100644
index 00000000000..66e63bcc39b
--- /dev/null
+++ b/test/util/opal_fd.c
@@ -0,0 +1,359 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2008-2018 Cisco Systems, Inc.  All rights reserved
+ * Copyright (c) 2009      Sandia National Laboratories. All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+#include "opal/util/fd.h"
+#include "opal/constants.h"
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdint.h>
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_fd_write / opal_fd_read round-trip via pipe
+ * ---------------------------------------------------------------------- */
+
+static void test_write_read_roundtrip(void)
+{
+    int fds[2];
+    const char src[] = "Hello, OPAL fd test!";
+    const int len = (int) (sizeof(src) - 1);   /* exclude NUL */
+    char dst[64];
+    int rc;
+
+    memset(dst, 0, sizeof(dst));
+
+    if (0 != pipe(fds)) {
+        test_verify("fd_write/read: pipe() succeeded", 0 == 1);
+        return;
+    }
+
+    rc = opal_fd_write(fds[1], len, src);
+    test_verify("fd_write: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* Close write end so read end does not block forever */
+    close(fds[1]);
+
+    rc = opal_fd_read(fds[0], len, dst);
+    test_verify("fd_read: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("fd_read: data matches what was written", 0 == memcmp(src, dst, (size_t) len));
+
+    close(fds[0]);
+}
+
+static void test_write_read_large_buffer(void)
+{
+    /*
+     * Exercise the multi-iteration write/read loops in opal_fd_write and
+     * opal_fd_read with a buffer larger than any platform's pipe capacity.
+     * opal_fd_write blocks until every byte is written, so the pipe must be
+     * drained concurrently -- writing a buffer bigger than the pipe with no
+     * reader would deadlock.  Fork a child to read while the parent writes;
+     * the child verifies the data (against its inherited copy of wbuf) and
+     * reports the result via its exit status.
+     */
+    const int len = 256 * 1024;   /* exceeds typical pipe capacities (16-64 KB) */
+    char *wbuf = malloc((size_t) len);
+    int fds[2];
+    int i;
+    pid_t pid;
+
+    if (NULL == wbuf) {
+        test_verify("fd_write/read large: malloc succeeded", 0 == 1);
+        return;
+    }
+
+    for (i = 0; i < len; i++) {
+        wbuf[i] = (char) (i & 0xff);
+    }
+
+    if (0 != pipe(fds)) {
+        test_verify("fd_write/read large: pipe() succeeded", 0 == 1);
+        free(wbuf);
+        return;
+    }
+
+    pid = fork();
+    if (-1 == pid) {
+        test_verify("fd_write/read large: fork() succeeded", 0 == 1);
+        close(fds[0]);
+        close(fds[1]);
+        free(wbuf);
+        return;
+    }
+
+    if (0 == pid) {
+        /* Child: drain the pipe and verify the bytes byte-for-byte against
+           the inherited copy of wbuf.  Exit 0 on success, non-zero on any
+           error or mismatch.  Do not call test_verify() here -- the child
+           has its own (separate) test counters. */
+        char *rbuf = malloc((size_t) len);
+        int child_status = 0;
+
+        close(fds[1]);   /* read end only */
+        if (NULL == rbuf) {
+            _exit(2);
+        }
+        if (OPAL_SUCCESS != opal_fd_read(fds[0], len, rbuf)
+            || 0 != memcmp(wbuf, rbuf, (size_t) len)) {
+            child_status = 1;
+        }
+        free(rbuf);
+        close(fds[0]);
+        _exit(child_status);
+    } else {
+        /* Parent: write the whole buffer, then reap the child. */
+        int rc;
+        int wstatus = 0;
+
+        close(fds[0]);   /* write end only */
+        rc = opal_fd_write(fds[1], len, wbuf);
+        test_verify("fd_write large: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+        close(fds[1]);
+
+        waitpid(pid, &wstatus, 0);
+        test_verify("fd_read large (child): data matches what was written",
+                    WIFEXITED(wstatus) && 0 == WEXITSTATUS(wstatus));
+        free(wbuf);
+    }
+}
+
+static void test_read_timeout_on_closed_pipe(void)
+{
+    /*
+     * Reading from a pipe whose write end has been closed with no data
+     * available should return OPAL_ERR_TIMEOUT (EOF before len bytes read).
+     */
+    int fds[2];
+    char buf[4];
+    int rc;
+
+    if (0 != pipe(fds)) {
+        test_verify("fd_read timeout: pipe() succeeded", 0 == 1);
+        return;
+    }
+
+    /* Close write end immediately -- no data written */
+    close(fds[1]);
+
+    rc = opal_fd_read(fds[0], (int) sizeof(buf), buf);
+    test_verify("fd_read: closed pipe with no data -> OPAL_ERR_TIMEOUT",
+                OPAL_ERR_TIMEOUT == rc);
+
+    close(fds[0]);
+}
+
+static void test_write_bad_fd(void)
+{
+    /*
+     * Writing to an invalid fd (-1) must return OPAL_ERR_IN_ERRNO.
+     */
+    const char buf[] = "data";
+    int rc = opal_fd_write(-1, (int) sizeof(buf), buf);
+    test_verify("fd_write to bad fd -> OPAL_ERR_IN_ERRNO", OPAL_ERR_IN_ERRNO == rc);
+}
+
+static void test_read_bad_fd(void)
+{
+    /*
+     * Reading from an invalid fd (-1) must return OPAL_ERR_IN_ERRNO.
+     */
+    char buf[4];
+    int rc = opal_fd_read(-1, (int) sizeof(buf), buf);
+    test_verify("fd_read from bad fd -> OPAL_ERR_IN_ERRNO", OPAL_ERR_IN_ERRNO == rc);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_fd_set_cloexec
+ * ---------------------------------------------------------------------- */
+
+static void test_set_cloexec(void)
+{
+    int fds[2];
+    int flags;
+    int rc;
+
+    if (0 != pipe(fds)) {
+        test_verify("fd_set_cloexec: pipe() succeeded", 0 == 1);
+        return;
+    }
+
+    rc = opal_fd_set_cloexec(fds[0]);
+    test_verify("fd_set_cloexec: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    flags = fcntl(fds[0], F_GETFD, 0);
+    test_verify("fd_set_cloexec: FD_CLOEXEC bit is set in fd flags",
+                (flags & FD_CLOEXEC) != 0);
+
+    close(fds[0]);
+    close(fds[1]);
+}
+
+static void test_set_cloexec_bad_fd(void)
+{
+    /*
+     * opal_fd_set_cloexec on an invalid fd: fcntl(F_GETFD) will fail
+     * so the function should return OPAL_ERR_IN_ERRNO.
+     * On platforms where FD_CLOEXEC is not defined the function is a no-op
+     * that returns OPAL_SUCCESS; we allow both outcomes.
+     */
+    int rc = opal_fd_set_cloexec(-1);
+    test_verify("fd_set_cloexec on bad fd: fails or is no-op (no crash)",
+                OPAL_ERR_IN_ERRNO == rc || OPAL_SUCCESS == rc);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_fd_is_regular
+ * ---------------------------------------------------------------------- */
+
+static void test_is_regular_tmpfile(void)
+{
+    char tmpfile[] = "/tmp/opal_fd_test_XXXXXX";
+    int fd = mkstemp(tmpfile);
+
+    if (-1 == fd) {
+        test_verify("fd_is_regular: mkstemp succeeded", 0 == 1);
+        return;
+    }
+
+    test_verify("fd_is_regular: mkstemp file is a regular file",
+                opal_fd_is_regular(fd));
+    test_verify("fd_is_regular: mkstemp file is NOT a char device",
+                !opal_fd_is_chardev(fd));
+    test_verify("fd_is_regular: mkstemp file is NOT a block device",
+                !opal_fd_is_blkdev(fd));
+
+    close(fd);
+    unlink(tmpfile);
+}
+
+static void test_is_regular_pipe(void)
+{
+    /*
+     * A pipe fd is NOT a regular file.
+     */
+    int fds[2];
+
+    if (0 != pipe(fds)) {
+        test_verify("fd_is_regular pipe: pipe() succeeded", 0 == 1);
+        return;
+    }
+
+    test_verify("fd_is_regular: pipe fd is NOT a regular file",
+                !opal_fd_is_regular(fds[0]));
+
+    close(fds[0]);
+    close(fds[1]);
+}
+
+static void test_is_regular_bad_fd(void)
+{
+    /* Invalid fd: fstat fails, so all three predicates return false */
+    test_verify("fd_is_regular bad fd: returns false", !opal_fd_is_regular(-1));
+    test_verify("fd_is_chardev bad fd: returns false", !opal_fd_is_chardev(-1));
+    test_verify("fd_is_blkdev bad fd: returns false",  !opal_fd_is_blkdev(-1));
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_fd_is_chardev
+ * ---------------------------------------------------------------------- */
+
+static void test_is_chardev_dev_null(void)
+{
+    /*
+     * /dev/null is always a character device on POSIX systems.
+     */
+    int fd = open("/dev/null", O_RDONLY);
+
+    if (-1 == fd) {
+        test_verify("fd_is_chardev: open /dev/null succeeded", 0 == 1);
+        return;
+    }
+
+    test_verify("fd_is_chardev: /dev/null is a character device",
+                opal_fd_is_chardev(fd));
+    test_verify("fd_is_regular: /dev/null is NOT a regular file",
+                !opal_fd_is_regular(fd));
+    test_verify("fd_is_blkdev: /dev/null is NOT a block device",
+                !opal_fd_is_blkdev(fd));
+
+    close(fd);
+}
+
+/* -----------------------------------------------------------------------
+ * Tests: opal_fd_is_blkdev
+ * ---------------------------------------------------------------------- */
+
+static void test_is_blkdev_tmpfile(void)
+{
+    /*
+     * A regular temp file is NOT a block device.
+     */
+    char tmpfile[] = "/tmp/opal_fd_blkdev_XXXXXX";
+    int fd = mkstemp(tmpfile);
+
+    if (-1 == fd) {
+        test_verify("fd_is_blkdev tmpfile: mkstemp succeeded", 0 == 1);
+        return;
+    }
+
+    test_verify("fd_is_blkdev: regular tmp file is NOT a block device",
+                !opal_fd_is_blkdev(fd));
+
+    close(fd);
+    unlink(tmpfile);
+}
+
+/* -----------------------------------------------------------------------
+ * main
+ * ---------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_fd");
+
+    /* opal_fd_write / opal_fd_read */
+    test_write_read_roundtrip();
+    test_write_read_large_buffer();
+    test_read_timeout_on_closed_pipe();
+    test_write_bad_fd();
+    test_read_bad_fd();
+
+    /* opal_fd_set_cloexec */
+    test_set_cloexec();
+    test_set_cloexec_bad_fd();
+
+    /* opal_fd_is_regular */
+    test_is_regular_tmpfile();
+    test_is_regular_pipe();
+    test_is_regular_bad_fd();
+
+    /* opal_fd_is_chardev */
+    test_is_chardev_dev_null();
+
+    /* opal_fd_is_blkdev */
+    test_is_blkdev_tmpfile();
+
+    return test_finalize();
+}
diff --git a/test/util/opal_few.c b/test/util/opal_few.c
new file mode 100644
index 00000000000..c5da230df82
--- /dev/null
+++ b/test/util/opal_few.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal_few().
+ *
+ * opal_few() forks/execs argv[0] (via execvp) and waits for it to exit.
+ * On success it returns OPAL_SUCCESS and fills *status with the raw
+ * waitpid(2) status word; the caller inspects it with the standard
+ * WIF* / WEXITSTATUS macros.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/few.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <sys/wait.h>
+#include <stdlib.h>
+
+/* ------------------------------------------------------------------ */
+/* helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+/*
+ * These tests invoke "true" and "false" by name (no leading path) so that
+ * opal_few()'s execvp() resolves them via PATH.  Passing a name without a
+ * slash is more portable than a hard-coded path: macOS has no /bin/true, and
+ * not every environment places these utilities under /usr/bin either.
+ */
+
+/*
+ * test_true_exits_zero
+ *
+ * Invoke true; expect:
+ *  - opal_few returns OPAL_SUCCESS  (child launched and exited)
+ *  - WIFEXITED(status) is true     (child exited normally, not signalled)
+ *  - WEXITSTATUS(status) == 0      (child reported success)
+ */
+static void test_true_exits_zero(void)
+{
+    int status = -1;
+    int rc;
+    char prog[] = "true";
+    char *argv[] = {prog, NULL};
+
+    rc = opal_few(argv, &status);
+    test_verify("opal_few(true) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("opal_few(true): WIFEXITED", WIFEXITED(status));
+    test_verify("opal_few(true): WEXITSTATUS == 0", 0 == WEXITSTATUS(status));
+}
+
+/*
+ * test_false_exits_nonzero
+ *
+ * Invoke false; expect:
+ *  - opal_few returns OPAL_SUCCESS  (child launched and exited)
+ *  - WIFEXITED(status) is true     (normal exit, not signalled)
+ *  - WEXITSTATUS(status) != 0      (child reported failure)
+ */
+static void test_false_exits_nonzero(void)
+{
+    int status = -1;
+    int rc;
+    char prog[] = "false";
+    char *argv[] = {prog, NULL};
+
+    rc = opal_few(argv, &status);
+    test_verify("opal_few(false) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("opal_few(false): WIFEXITED", WIFEXITED(status));
+    test_verify("opal_few(false): WEXITSTATUS != 0", 0 != WEXITSTATUS(status));
+}
+
+/*
+ * test_status_word_is_waitpid_form
+ *
+ * Confirm that opal_few fills the raw waitpid status word, not just
+ * the exit code.  After a normal exit WIFSIGNALED must be false.
+ */
+static void test_status_word_is_waitpid_form(void)
+{
+    int status = -1;
+    char prog[] = "true";
+    char *argv[] = {prog, NULL};
+
+    opal_few(argv, &status);
+    test_verify("opal_few status: WIFSIGNALED is false for normal exit",
+                !WIFSIGNALED(status));
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    test_init("opal_few");
+
+    opal_init_util(&argc, &argv);
+
+    test_true_exits_zero();
+    test_false_exits_nonzero();
+    test_status_word_is_waitpid_form();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_getcwd.c b/test/util/opal_getcwd.c
new file mode 100644
index 00000000000..4f652114547
--- /dev/null
+++ b/test/util/opal_getcwd.c
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#    include <unistd.h>
+#endif
+#ifdef HAVE_SYS_TYPES_H
+#    include <sys/types.h>
+#endif
+
+#include "support.h"
+#include "opal/util/opal_getcwd.h"
+#include "opal/constants.h"
+
+int main(int argc, char *argv[])
+{
+    char buf[OPAL_PATH_MAX];
+    char libc_cwd[OPAL_PATH_MAX];
+    int rc;
+
+    test_init("opal_getcwd");
+
+    /* ================================================================
+     * Get the ground-truth cwd from libc for comparison.
+     * Unset $PWD first so opal_getcwd() always falls back to getcwd()
+     * on the success path, giving us a deterministic string to compare.
+     * ================================================================ */
+    unsetenv("PWD");
+
+    if (NULL == getcwd(libc_cwd, sizeof(libc_cwd))) {
+        /* Cannot determine cwd; skip the comparison tests. */
+        test_verify("libc getcwd() baseline succeeded", 0 /* always fail: no cwd */);
+        return test_finalize();
+    }
+
+    /* ================================================================
+     * NULL buf -> OPAL_ERR_BAD_PARAM
+     * ================================================================ */
+    rc = opal_getcwd(NULL, sizeof(buf));
+    test_verify("NULL buf: returns OPAL_ERR_BAD_PARAM", OPAL_ERR_BAD_PARAM == rc);
+
+    /* ================================================================
+     * size > INT_MAX -> OPAL_ERR_BAD_PARAM
+     * ================================================================ */
+    rc = opal_getcwd(buf, (size_t) INT_MAX + 1);
+    test_verify("size>INT_MAX: returns OPAL_ERR_BAD_PARAM", OPAL_ERR_BAD_PARAM == rc);
+
+    /* ================================================================
+     * Normal success: $PWD is unset so opal_getcwd falls back to
+     * getcwd() result.
+     * ================================================================ */
+    memset(buf, 0, sizeof(buf));
+    rc = opal_getcwd(buf, sizeof(buf));
+    test_verify("normal success: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("normal success: buf matches getcwd()",
+                0 == strcmp(buf, libc_cwd));
+
+    /* ================================================================
+     * $PWD is set to the same value as getcwd() -> should succeed and
+     * return that same value.
+     * ================================================================ */
+    setenv("PWD", libc_cwd, 1 /*overwrite*/);
+    memset(buf, 0, sizeof(buf));
+    rc = opal_getcwd(buf, sizeof(buf));
+    test_verify("PWD==cwd: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("PWD==cwd: buf matches libc cwd", 0 == strcmp(buf, libc_cwd));
+    unsetenv("PWD");
+
+    /* ================================================================
+     * Buffer too small -> OPAL_ERR_TEMP_OUT_OF_RESOURCE.
+     * Provide a 1-byte buffer.  strlen(cwd) > 1 for any real directory.
+     * The function falls back to writing (part of) the basename.
+     * ================================================================ */
+    {
+        char tiny[2];
+        memset(tiny, 0xFF, sizeof(tiny));
+        rc = opal_getcwd(tiny, sizeof(tiny));
+        test_verify("tiny buf: returns OPAL_ERR_TEMP_OUT_OF_RESOURCE",
+                    OPAL_ERR_TEMP_OUT_OF_RESOURCE == rc);
+        /* buf must still be NUL-terminated within the provided size */
+        test_verify("tiny buf: NUL-terminated", '\0' == tiny[sizeof(tiny) - 1]);
+    }
+
+    /* ================================================================
+     * $PWD set to a stale / non-existent path -> opal_getcwd must fall
+     * back to getcwd() and still return OPAL_SUCCESS.
+     * ================================================================ */
+    setenv("PWD", "/this/path/does/not/exist/at/all/9z8y7x6w", 1);
+    memset(buf, 0, sizeof(buf));
+    rc = opal_getcwd(buf, sizeof(buf));
+    test_verify("stale PWD: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("stale PWD: buf matches getcwd()", 0 == strcmp(buf, libc_cwd));
+    unsetenv("PWD");
+
+    /*
+     * Boundary: a buffer of exactly strlen(cwd) bytes cannot hold the
+     * cwd plus its NUL terminator.  opal_getcwd() must report
+     * OPAL_ERR_TEMP_OUT_OF_RESOURCE rather than silently truncating and
+     * (incorrectly) returning OPAL_SUCCESS.
+     */
+    {
+        size_t exact = strlen(libc_cwd);
+        char small[OPAL_PATH_MAX];
+        memset(small, 0, sizeof(small));
+        rc = opal_getcwd(small, exact);
+        test_verify("buffer == strlen(cwd): reports OUT_OF_RESOURCE",
+                    OPAL_ERR_TEMP_OUT_OF_RESOURCE == rc);
+    }
+
+    return test_finalize();
+}
diff --git a/test/util/opal_if.c b/test/util/opal_if.c
index 20d5def9ca2..cd422688881 100644
--- a/test/util/opal_if.c
+++ b/test/util/opal_if.c
@@ -2,15 +2,14 @@
  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
  *                         University Research and Technology
  *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
- * Copyright (c) 2019      Triad National Security, LLC. All rights
- *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -18,118 +17,389 @@
  * $HEADER$
  */
 
-#include "ompi_config.h"
+/*
+ * Unit tests for the OPAL network-interface enumeration API (opal/util/if.h
+ * and the opal/mca/if framework).
+ *
+ * Strategy:
+ *   1. opal_init() brings up the MCA if framework (opal_init_util() alone
+ *      does not open it); only then is the interface list populated.
+ *   2. We assert opal_ifcount() >= 1 (at minimum a loopback exists).
+ *   3. We iterate all interfaces with opal_ifbegin()/opal_ifnext() and
+ *      cross-check every round-trip:
+ *        index -> name -> index
+ *        index -> kindex -> kindex-name  (must equal the index-name)
+ *        name  -> kindex
+ *   4. We locate the loopback by address (127.x.x.x) rather than by
+ *      name ("lo" vs "lo0"), then assert opal_ifisloopback() is true.
+ *   5. opal_ifislocal() is exercised with known-local / known-remote strings.
+ *
+ * The loopback interface is enumerated only when the MCA parameter
+ * if_base_retain_loopback is set: the BSD enumerator (opal/mca/if/bsdx_ipv4,
+ * used on the *BSDs including FreeBSD) honors it and drops loopback by
+ * default, while the posix_ipv4 component (used on Linux and macOS) has had
+ * its loopback filter #if 0'd out since 2010 and so always keeps loopback,
+ * regardless of the parameter.  To exercise the loopback-related API
+ * uniformly across platforms, main() sets that parameter before opal_init()
+ * (see below).  This long-standing cross-platform divergence (and the
+ * options for resolving it in OPAL) is tracked in
+ * https://github.com/open-mpi/ompi/issues/14029.
+ *
+ * NOTE: -DNDEBUG is set; assert() is a no-op.  All verification MUST
+ * use test_verify() / test_failure().  Never use assert().
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/if.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#ifdef HAVE_SYS_PARAM_H
-#    include <sys/param.h>
-#endif
-#ifdef HAVE_NETINET_IN_H
-#    include <netinet/in.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#    include <unistd.h>
-#endif
-#ifdef HAVE_NETDB_H
-#    include <netdb.h>
-#endif
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <net/if.h>
 
-#include "opal/constants.h"
-#include "opal/runtime/opal.h"
-#include "opal/util/if.h"
-#include "support.h"
+/* ------------------------------------------------------------------ */
+/* Helpers                                                             */
+/* ------------------------------------------------------------------ */
 
-static bool test_ifaddrtoname(char *addr)
+/*
+ * Return true if the given sockaddr contains an IPv4 address in the
+ * 127.0.0.0/8 loopback range.
+ */
+static int
+addr_is_ipv4_loopback(const struct sockaddr *sa)
 {
-    int ret;
-    char addrname[100];
-    int len = 99;
+    if (NULL == sa || AF_INET != sa->sa_family) {
+        return 0;
+    }
+    {
+        const struct sockaddr_in *sin = (const struct sockaddr_in *) sa;
+        uint32_t h = ntohl(sin->sin_addr.s_addr);
+        return ((h & 0xFF000000u) == 0x7F000000u);
+    }
+}
 
-    ret = opal_ifaddrtoname(addr, addrname, len);
+/* ------------------------------------------------------------------ */
+/* Test: opal_ifcount                                                  */
+/* ------------------------------------------------------------------ */
 
-    if (ret == OPAL_SUCCESS) {
-        return true;
-    } else {
-        return false;
-    }
+static void
+test_ifcount(void)
+{
+    int count = opal_ifcount();
+    test_verify("opal_ifcount() >= 1 (loopback always present)", count >= 1);
 }
 
-int main(int argc, char *argv[])
+/* ------------------------------------------------------------------ */
+/* Test: iterate with opal_ifbegin / opal_ifnext                       */
+/* ------------------------------------------------------------------ */
+
+static void
+test_iteration(void)
 {
-    const char *hostname;
+    int idx;
+    int count_iter = 0;
+    int expected_count = opal_ifcount();
 
-    opal_init(&argc, &argv);
-    test_init("opal_if");
+    idx = opal_ifbegin();
+    test_verify("opal_ifbegin() > 0", idx > 0);
 
-    /* 127.0.0.1 */
-    if (test_ifaddrtoname("127.0.0.1")) {
-        test_success();
-    } else {
-        test_failure("ifaddrtoname test failed for 127.0.0.1");
-    }
-    if (opal_ifislocal("127.0.0.1")) {
-        test_success();
-    } else {
-        test_failure("ifislocal test failed for 127.0.0.1");
+    while (idx > 0) {
+        count_iter++;
+        idx = opal_ifnext(idx);
     }
 
-    /* localhost */
-    if (test_ifaddrtoname("localhost")) {
-        test_success();
-    } else {
-        test_failure("ifaddrtoname test failed for localhost");
-    }
-    if (opal_ifislocal("localhost")) {
-        test_success();
-    } else {
-        test_failure("ifislocal test failed for localhost");
-    }
+    test_verify("iteration count equals opal_ifcount()", count_iter == expected_count);
+}
 
-    /* 0.0.0.0 */
-    if (test_ifaddrtoname("0.0.0.0")) {
-        test_failure("ifaddrtoname test failed for 0.0.0.0");
-    } else {
-        test_success();
+/* ------------------------------------------------------------------ */
+/* Test: index <-> name round-trips and name -> kindex                 */
+/* ------------------------------------------------------------------ */
+
+static void
+test_index_name_roundtrips(void)
+{
+    int idx;
+
+    for (idx = opal_ifbegin(); idx > 0; idx = opal_ifnext(idx)) {
+        char name1[OPAL_IF_NAMESIZE];
+        char name2[OPAL_IF_NAMESIZE];
+        char kname[OPAL_IF_NAMESIZE];
+        int  back_idx;
+        int  kindex;
+        int  rc;
+
+        /* index -> name */
+        rc = opal_ifindextoname(idx, name1, (int) sizeof(name1));
+        test_verify("opal_ifindextoname() returns OPAL_SUCCESS",
+                    OPAL_SUCCESS == rc);
+        test_verify("opal_ifindextoname() produces non-empty name",
+                    '\0' != name1[0]);
+
+        /* name -> index (round-trip) */
+        back_idx = opal_ifnametoindex(name1);
+        test_verify("opal_ifnametoindex(opal_ifindextoname()) round-trips back",
+                    back_idx == idx);
+
+        /* index -> kindex */
+        kindex = opal_ifindextokindex(idx);
+        test_verify("opal_ifindextokindex() returns positive kindex",
+                    kindex > 0);
+
+        /* kindex -> name */
+        rc = opal_ifkindextoname(kindex, kname, (int) sizeof(kname));
+        test_verify("opal_ifkindextoname() returns OPAL_SUCCESS",
+                    OPAL_SUCCESS == rc);
+
+        /* kindex-name must match index-name */
+        test_verify("opal_ifkindextoname() matches opal_ifindextoname()",
+                    0 == strcmp(name1, kname));
+
+        /* name -> kindex (must match) */
+        {
+            int k2 = opal_ifnametokindex(name1);
+            test_verify("opal_ifnametokindex() matches opal_ifindextokindex()",
+                        k2 == kindex);
+        }
+
+        /* index -> name again via second call -- must be stable */
+        rc = opal_ifindextoname(idx, name2, (int) sizeof(name2));
+        test_verify("opal_ifindextoname() is stable across calls",
+                    OPAL_SUCCESS == rc && 0 == strcmp(name1, name2));
     }
-    if (opal_ifislocal("0.0.0.0")) {
-        test_failure("opal_ifislocal test failed for 0.0.0.0");
-    } else {
-        test_success();
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_ifnametoaddr / opal_ifaddrtoname round-trips             */
+/* ------------------------------------------------------------------ */
+
+static void
+test_name_addr_roundtrips(void)
+{
+    int idx;
+
+    /*
+     * Deterministic anchor: with if_base_retain_loopback set (see main()),
+     * 127.0.0.1 is in the interface list on any conforming host.
+     * opal_ifaddrtoname() must return OPAL_SUCCESS for it and fill in a
+     * non-empty interface name.
+     */
+    {
+        char loopback_ifname[OPAL_IF_NAMESIZE];
+        int rc = opal_ifaddrtoname("127.0.0.1",
+                                   loopback_ifname,
+                                   (int) sizeof(loopback_ifname));
+        test_verify("opal_ifaddrtoname(\"127.0.0.1\") returns OPAL_SUCCESS",
+                    OPAL_SUCCESS == rc);
+        test_verify("opal_ifaddrtoname(\"127.0.0.1\") produces non-empty name",
+                    '\0' != loopback_ifname[0]);
     }
 
-    /* foo.example.com */
-    printf("This should generate a warning:\n");
-    fflush(stdout);
-    if (test_ifaddrtoname("foo.example.com")) {
-        test_failure("ifaddrtoname test failed for foo.example.com");
-    } else {
-        test_success();
+    /*
+     * Per-interface: for each interface with an IPv4 address, convert
+     * the address to a dotted-quad string and call opal_ifaddrtoname().
+     * We also verify opal_ifnametoaddr() returns a non-zero address family.
+     */
+    for (idx = opal_ifbegin(); idx > 0; idx = opal_ifnext(idx)) {
+        char name[OPAL_IF_NAMESIZE];
+        struct sockaddr_storage ss;
+        int rc;
+
+        rc = opal_ifindextoname(idx, name, (int) sizeof(name));
+        if (OPAL_SUCCESS != rc) {
+            continue; /* already caught in test_index_name_roundtrips */
+        }
+
+        /* name -> addr */
+        rc = opal_ifnametoaddr(name,
+                               (struct sockaddr *) &ss,
+                               (int) sizeof(ss));
+        if (OPAL_SUCCESS != rc) {
+            /* some virtual interfaces may have no address; skip */
+            continue;
+        }
+
+        test_verify("opal_ifnametoaddr() address family is AF_INET or AF_INET6",
+                    AF_INET  == ((struct sockaddr *) &ss)->sa_family ||
+                    AF_INET6 == ((struct sockaddr *) &ss)->sa_family);
+
+        /*
+         * addr -> name (dotted-quad round-trip for IPv4 only).
+         * We do not assert the recovered name matches the original because
+         * a single address may appear under multiple interface indices.
+         * We assert the call returns OPAL_SUCCESS (the address exists in the
+         * list).
+         */
+        if (AF_INET == ((struct sockaddr *) &ss)->sa_family) {
+            char dotquad[INET_ADDRSTRLEN];
+            char back_name[OPAL_IF_NAMESIZE];
+
+            inet_ntop(AF_INET,
+                      &((struct sockaddr_in *) &ss)->sin_addr,
+                      dotquad, sizeof(dotquad));
+
+            rc = opal_ifaddrtoname(dotquad, back_name, (int) sizeof(back_name));
+            test_verify("opal_ifaddrtoname() succeeds for address from opal_ifnametoaddr()",
+                        OPAL_SUCCESS == rc);
+        }
     }
-    printf("This should generate a warning:\n");
-    fflush(stdout);
-    if (opal_ifislocal("foo.example.com")) {
-        test_failure("ifislocal test failed for foo.example.com");
-    } else {
-        test_success();
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: find the loopback interface; assert opal_ifisloopback         */
+/* ------------------------------------------------------------------ */
+
+static void
+test_loopback(void)
+{
+    int idx;
+    int found_loopback_index = -1;
+
+    for (idx = opal_ifbegin(); idx > 0; idx = opal_ifnext(idx)) {
+        struct sockaddr_storage ss;
+        int rc;
+        int is_loopback = 0;
+
+        rc = opal_ifindextoaddr(idx,
+                                (struct sockaddr *) &ss,
+                                (unsigned int) sizeof(ss));
+        if (OPAL_SUCCESS != rc) {
+            continue;
+        }
+
+        /* Accept IPv4 loopback (127.x.x.x) */
+        if (addr_is_ipv4_loopback((struct sockaddr *) &ss)) {
+            is_loopback = 1;
+        }
+
+#if OPAL_ENABLE_IPV6
+        /* Also accept IPv6 loopback (::1) */
+        if (!is_loopback && AF_INET6 == ((struct sockaddr *) &ss)->sa_family) {
+            const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *) &ss;
+            if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr)) {
+                is_loopback = 1;
+            }
+        }
+#endif /* OPAL_ENABLE_IPV6 */
+
+        if (is_loopback && -1 == found_loopback_index) {
+            found_loopback_index = idx;
+        }
     }
 
-    /* local host name */
-    hostname = opal_gethostname();
-    if (test_ifaddrtoname(hostname)) {
-        test_success();
-    } else {
-        test_failure("ifaddrtoname test failed for local host name");
+    test_verify("at least one loopback interface found",
+                found_loopback_index > 0);
+
+    if (found_loopback_index > 0) {
+        test_verify("opal_ifisloopback() true for loopback interface",
+                    opal_ifisloopback(found_loopback_index));
     }
-    if (opal_ifislocal(hostname)) {
-        test_success();
-    } else {
-        test_failure("ifislocal test failed for local host name");
+
+    /* Check that 127.0.0.1 is reported as local */
+    test_verify("opal_ifislocal(\"127.0.0.1\") is true",
+                opal_ifislocal("127.0.0.1"));
+    test_verify("opal_ifislocal(\"localhost\") is true",
+                opal_ifislocal("localhost"));
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_ifislocal negative cases                                 */
+/* ------------------------------------------------------------------ */
+
+static void
+test_ifislocal_negative(void)
+{
+    /*
+     * foo.example.com is an IANA-reserved domain that will not resolve
+     * to any local interface on any conforming host.
+     */
+    test_verify("opal_ifislocal(\"foo.example.com\") is false",
+                !opal_ifislocal("foo.example.com"));
+
+    /* 0.0.0.0 is not a local interface address */
+    test_verify("opal_ifislocal(\"0.0.0.0\") is false",
+                !opal_ifislocal("0.0.0.0"));
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: error / boundary cases                                        */
+/* ------------------------------------------------------------------ */
+
+static void
+test_boundary_cases(void)
+{
+    char name[OPAL_IF_NAMESIZE];
+
+    /* Negative index must fail gracefully */
+    test_verify("opal_ifindextoname(-1) does not succeed",
+                OPAL_SUCCESS != opal_ifindextoname(-1, name, (int) sizeof(name)));
+
+    /* Zero index must fail gracefully */
+    test_verify("opal_ifindextoname(0) does not succeed",
+                OPAL_SUCCESS != opal_ifindextoname(0, name, (int) sizeof(name)));
+
+    /* Non-existent name */
+    test_verify("opal_ifnametoindex(\"__no_such_iface__\") returns negative",
+                opal_ifnametoindex("__no_such_iface__") < 0);
+
+    /* opal_ifnext at end must return <= 0 */
+    {
+        int last_idx = opal_ifbegin();
+        int next;
+        while ((next = opal_ifnext(last_idx)) > 0) {
+            last_idx = next;
+        }
+        test_verify("opal_ifnext() past last interface returns <= 0",
+                    opal_ifnext(last_idx) <= 0);
     }
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int rc;
+
+    /*
+     * Ask the MCA "if" framework to retain loopback interfaces.  This
+     * parameter defaults to false, and the BSD interface enumerator
+     * (opal/mca/if/bsdx_ipv4, used on the *BSDs) honors it and drops the
+     * loopback interface -- so without this, 127.0.0.1 / lo0 would not be in
+     * the interface list and the loopback-related checks below could not run.
+     * (Linux and macOS use posix_ipv4, whose loopback filter has been #if 0'd
+     * out since 2010, so loopback is always present there regardless of this
+     * setting.)  Set the MCA parameter via the environment before opal_init()
+     * reads it; the "if" base registers the variable during opal_init(),
+     * overwriting any direct assignment to the global, so the environment is
+     * the reliable knob.  This platform divergence (and options for fixing it
+     * in OPAL) is tracked in https://github.com/open-mpi/ompi/issues/14029.
+     */
+    setenv("OMPI_MCA_if_base_retain_loopback", "1", 1);
 
-    test_finalize();
-    opal_finalize();
+    rc = opal_init(&argc, &argv);
+    test_init("opal_if");
+    test_verify("opal_init() succeeds", OPAL_SUCCESS == rc);
 
-    return 0;
+    test_ifcount();
+    test_iteration();
+    test_index_name_roundtrips();
+    test_name_addr_roundtrips();
+    test_loopback();
+    test_ifislocal_negative();
+    test_boundary_cases();
+
+    {
+        int r = test_finalize();
+        opal_finalize();
+        return r;
+    }
 }
diff --git a/test/util/opal_info.c b/test/util/opal_info.c
new file mode 100644
index 00000000000..9539a3da3fe
--- /dev/null
+++ b/test/util/opal_info.c
@@ -0,0 +1,573 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2010 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2021 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2007-2018 Cisco Systems, Inc.  All rights reserved
+ * Copyright (c) 2012-2017 Los Alamos National Security, LLC. All rights
+ *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal_info_t -- the key/value list backing MPI_Info.
+ *
+ * Library is compiled with -DNDEBUG, so assert() is a no-op.
+ * All verification must go through test_verify().
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/info.h"
+#include "opal/mca/base/mca_base_var_enum.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* ------------------------------------------------------------------ */
+/* Forward declarations                                                */
+/* ------------------------------------------------------------------ */
+
+static void test_set_and_get(void);
+static void test_set_cstring(void);
+static void test_get_missing_key(void);
+static void test_overwrite(void);
+static void test_delete(void);
+static void test_get_nthkey(void);
+static void test_get_valuelen(void);
+static void test_get_nkeys(void);
+static void test_get_bool(void);
+static void test_get_value_enum(void);
+static void test_dup(void);
+static void test_dup_public(void);
+static void test_free(void);
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    test_init("opal_info_t");
+
+    opal_init_util(&argc, &argv);
+
+    test_set_and_get();
+    test_set_cstring();
+    test_get_missing_key();
+    test_overwrite();
+    test_delete();
+    test_get_nthkey();
+    test_get_valuelen();
+    test_get_nkeys();
+    test_get_bool();
+    test_get_value_enum();
+    test_dup();
+    test_dup_public();
+    test_free();
+
+    int r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+/* Helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Create a new opal_info_t, set key=value, read it back, verify the
+ * string content and flag, then release the returned cstring and the
+ * info object.
+ */
+static void test_set_and_get(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    /* Basic set + get */
+    int rc = opal_info_set(info, "mykey", "myvalue");
+    test_verify("set returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    rc = opal_info_get(info, "mykey", &val, &flag);
+    test_verify("get returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 for existing key", 1 == flag);
+    test_verify("value string matches", NULL != val && 0 == strcmp(val->string, "myvalue"));
+    test_verify("value length matches", NULL != val && val->length == strlen("myvalue"));
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_set_cstring(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    opal_cstring_t *cs = opal_cstring_create("cstring_val");
+    test_verify("cstring creation succeeds", NULL != cs);
+
+    int rc = opal_info_set_cstring(info, "cskey", cs);
+    test_verify("set_cstring returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* Release caller's reference -- info must have retained its own */
+    OBJ_RELEASE(cs);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    rc = opal_info_get(info, "cskey", &val, &flag);
+    test_verify("get after set_cstring succeeds", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 after set_cstring", 1 == flag);
+    test_verify("value matches cstring content",
+                NULL != val && 0 == strcmp(val->string, "cstring_val"));
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_missing_key(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    /* get on an empty info must set flag=0 and return OPAL_SUCCESS */
+    opal_cstring_t *val = NULL;
+    int flag = 42; /* sentinel -- should be set to 0 */
+    int rc = opal_info_get(info, "nosuchkey", &val, &flag);
+    test_verify("get on missing key returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 0 for missing key", 0 == flag);
+    /* val must not have been written when flag==0 */
+    test_verify("val pointer not modified when flag==0", NULL == val);
+
+    /* get_valuelen on missing key: flag=0, valuelen untouched */
+    int vlen = 999;
+    flag = 42;
+    rc = opal_info_get_valuelen(info, "nosuchkey", &vlen, &flag);
+    test_verify("get_valuelen on missing key returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 0 for missing key (valuelen)", 0 == flag);
+    test_verify("valuelen untouched for missing key", 999 == vlen);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_overwrite(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    opal_info_set(info, "key", "first");
+    int rc = opal_info_set(info, "key", "second");
+    test_verify("overwrite returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    opal_info_get(info, "key", &val, &flag);
+    test_verify("flag is still 1 after overwrite", 1 == flag);
+    test_verify("value reflects new content after overwrite",
+                NULL != val && 0 == strcmp(val->string, "second"));
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    /* Only one key should exist (no phantom entries) */
+    int nkeys = -1;
+    opal_info_get_nkeys(info, &nkeys);
+    test_verify("only one entry after overwrite", 1 == nkeys);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_delete(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    opal_info_set(info, "a", "1");
+    opal_info_set(info, "b", "2");
+
+    /* delete existing key */
+    int rc = opal_info_delete(info, "a");
+    test_verify("delete existing key returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    opal_info_get(info, "a", &val, &flag);
+    test_verify("deleted key is not found", 0 == flag);
+
+    /* "b" must still be accessible */
+    flag = 0;
+    opal_info_get(info, "b", &val, &flag);
+    test_verify("remaining key still accessible after delete", 1 == flag);
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    /* delete non-existent key */
+    rc = opal_info_delete(info, "nosuchkey");
+    test_verify("delete missing key returns OPAL_ERR_NOT_FOUND",
+                OPAL_ERR_NOT_FOUND == rc);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_nthkey(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    opal_info_set(info, "alpha", "1");
+    opal_info_set(info, "beta",  "2");
+    opal_info_set(info, "gamma", "3");
+
+    /* Keys must be returned in insertion order (MPI-3.1 § 9.1) */
+    opal_cstring_t *key0 = NULL;
+    int rc = opal_info_get_nthkey(info, 0, &key0);
+    test_verify("get_nthkey(0) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("0th key is \"alpha\"",
+                NULL != key0 && 0 == strcmp(key0->string, "alpha"));
+    if (NULL != key0) {
+        OBJ_RELEASE(key0);
+    }
+
+    opal_cstring_t *key1 = NULL;
+    rc = opal_info_get_nthkey(info, 1, &key1);
+    test_verify("get_nthkey(1) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("1st key is \"beta\"",
+                NULL != key1 && 0 == strcmp(key1->string, "beta"));
+    if (NULL != key1) {
+        OBJ_RELEASE(key1);
+    }
+
+    opal_cstring_t *key2 = NULL;
+    rc = opal_info_get_nthkey(info, 2, &key2);
+    test_verify("get_nthkey(2) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("2nd key is \"gamma\"",
+                NULL != key2 && 0 == strcmp(key2->string, "gamma"));
+    if (NULL != key2) {
+        OBJ_RELEASE(key2);
+    }
+
+    /* Out-of-range index must return OPAL_ERR_BAD_PARAM */
+    opal_cstring_t *keyX = NULL;
+    rc = opal_info_get_nthkey(info, 3, &keyX);
+    test_verify("get_nthkey(out of range) returns OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == rc);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_valuelen(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    const char *v = "hello";
+    opal_info_set(info, "k", v);
+
+    int vlen = 0;
+    int flag = 0;
+    int rc = opal_info_get_valuelen(info, "k", &vlen, &flag);
+    test_verify("get_valuelen returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 for existing key", 1 == flag);
+    /* The spec says the C length does not include the NUL terminator */
+    test_verify("valuelen equals strlen(value)", (int) strlen(v) == vlen);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_nkeys(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    int nkeys = -1;
+    opal_info_get_nkeys(info, &nkeys);
+    test_verify("nkeys of fresh info is 0", 0 == nkeys);
+
+    opal_info_set(info, "x", "1");
+    opal_info_set(info, "y", "2");
+    opal_info_get_nkeys(info, &nkeys);
+    test_verify("nkeys is 2 after two sets", 2 == nkeys);
+
+    opal_info_delete(info, "x");
+    opal_info_get_nkeys(info, &nkeys);
+    test_verify("nkeys is 1 after a delete", 1 == nkeys);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_bool(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    /* "true" -> true */
+    opal_info_set(info, "btrue", "true");
+    bool bval = false;
+    int flag = 0;
+    int rc = opal_info_get_bool(info, "btrue", &bval, &flag);
+    test_verify("get_bool(\"true\") returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 for \"true\"", 1 == flag);
+    test_verify("\"true\" parses as true", true == bval);
+
+    /* "false" -> false */
+    opal_info_set(info, "bfalse", "false");
+    bval = true;
+    flag = 0;
+    rc = opal_info_get_bool(info, "bfalse", &bval, &flag);
+    test_verify("get_bool(\"false\") returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 for \"false\"", 1 == flag);
+    test_verify("\"false\" parses as false", false == bval);
+
+    /* "1" -> true */
+    opal_info_set(info, "bone", "1");
+    bval = false;
+    flag = 0;
+    rc = opal_info_get_bool(info, "bone", &bval, &flag);
+    test_verify("get_bool(\"1\") returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 for \"1\"", 1 == flag);
+    test_verify("\"1\" parses as true", true == bval);
+
+    /* "0" -> false */
+    opal_info_set(info, "bzero", "0");
+    bval = true;
+    flag = 0;
+    rc = opal_info_get_bool(info, "bzero", &bval, &flag);
+    test_verify("get_bool(\"0\") returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 for \"0\"", 1 == flag);
+    test_verify("\"0\" parses as false", false == bval);
+
+    /* "yes" -> true (case-insensitive) */
+    opal_info_set(info, "byes", "YES");
+    bval = false;
+    flag = 0;
+    rc = opal_info_get_bool(info, "byes", &bval, &flag);
+    test_verify("get_bool(\"YES\") returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("\"YES\" parses as true", true == bval);
+
+    /* "no" -> false (case-insensitive) */
+    opal_info_set(info, "bno", "NO");
+    bval = true;
+    flag = 0;
+    rc = opal_info_get_bool(info, "bno", &bval, &flag);
+    test_verify("get_bool(\"NO\") returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("\"NO\" parses as false", false == bval);
+
+    /* missing key: flag==0, return OPAL_SUCCESS */
+    flag = 42;
+    rc = opal_info_get_bool(info, "nosuchkey", &bval, &flag);
+    test_verify("get_bool(missing key) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 0 for missing key", 0 == flag);
+
+    /*
+     * Present key whose value "junk" is not a recognized boolean string.
+     * opal_info_get_bool() delegates to opal_cstring_to_bool(), which is
+     * documented (opal/class/opal_cstring.h) to return OPAL_ERR_BAD_PARAM
+     * and set its output to false for unrecognized values.  flag is 1
+     * because the key itself IS present; the "all other values are false"
+     * wording in info.h governs the bool output, not the return code.
+     */
+    opal_info_set(info, "bjunk", "junk");
+    bval = true;
+    flag = 0;
+    rc = opal_info_get_bool(info, "bjunk", &bval, &flag);
+    test_verify("flag is 1 for present key with junk value", 1 == flag);
+    test_verify("get_bool(\"junk\") returns OPAL_ERR_BAD_PARAM",
+                OPAL_ERR_BAD_PARAM == rc);
+    test_verify("\"junk\" yields false", false == bval);
+
+    OBJ_RELEASE(info);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_get_value_enum(void)
+{
+    /* Build a tiny enumerator: "low"=0, "high"=1 */
+    mca_base_var_enum_value_t vals[] = {
+        { 0, "low"  },
+        { 1, "high" },
+        { 0, NULL   }  /* sentinel */
+    };
+    mca_base_var_enum_t *venum = NULL;
+    int rc = mca_base_var_enum_create("test_enum", vals, &venum);
+    test_verify("mca_base_var_enum_create succeeds", OPAL_SUCCESS == rc && NULL != venum);
+    if (NULL == venum) {
+        return;
+    }
+
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+
+    opal_info_set(info, "level", "high");
+
+    int out_val = -1;
+    int flag = 0;
+    rc = opal_info_get_value_enum(info, "level", &out_val, 0, venum, &flag);
+    test_verify("get_value_enum returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 1 for existing key", 1 == flag);
+    test_verify("\"high\" resolves to integer 1", 1 == out_val);
+
+    /* "low" -> 0 */
+    opal_info_set(info, "level2", "low");
+    out_val = -1;
+    flag = 0;
+    rc = opal_info_get_value_enum(info, "level2", &out_val, 99, venum, &flag);
+    test_verify("get_value_enum \"low\" returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("\"low\" resolves to integer 0", 0 == out_val);
+
+    /* missing key: default_value must be returned, flag==0 */
+    out_val = -1;
+    flag = 42;
+    rc = opal_info_get_value_enum(info, "nokey", &out_val, 77, venum, &flag);
+    test_verify("get_value_enum on missing key returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("flag is 0 for missing key", 0 == flag);
+    test_verify("default_value used when key missing", 77 == out_val);
+
+    OBJ_RELEASE(info);
+    OBJ_RELEASE(venum);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_dup(void)
+{
+    opal_info_t *src = OBJ_NEW(opal_info_t);
+
+    opal_info_set(src, "k1", "v1");
+    opal_info_set(src, "k2", "v2");
+    /* internal key -- dup() must copy it too */
+    opal_info_set_internal(src, "k3_internal", "v3");
+
+    /* opal_info_dup does NOT allocate *newinfo -- caller must do it */
+    opal_info_t *dst = OBJ_NEW(opal_info_t);
+    int rc = opal_info_dup(src, &dst);
+    test_verify("opal_info_dup returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* All three entries (including internal) must appear in dst */
+    int nkeys = -1;
+    opal_info_get_nkeys(dst, &nkeys);
+    test_verify("dup copies all keys including internal", 3 == nkeys);
+
+    /* Verify key order and values */
+    opal_cstring_t *key0 = NULL;
+    opal_info_get_nthkey(dst, 0, &key0);
+    test_verify("dup preserves key order (0 = k1)",
+                NULL != key0 && 0 == strcmp(key0->string, "k1"));
+    if (NULL != key0) OBJ_RELEASE(key0);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    opal_info_get(dst, "k2", &val, &flag);
+    test_verify("dup copies value of k2", 1 == flag &&
+                NULL != val && 0 == strcmp(val->string, "v2"));
+    if (NULL != val) OBJ_RELEASE(val);
+
+    /* Changes to dst must not affect src */
+    opal_info_set(dst, "k1", "modified");
+    val = NULL; flag = 0;
+    opal_info_get(src, "k1", &val, &flag);
+    test_verify("dup is a deep copy -- src unaffected by dst change",
+                1 == flag && NULL != val && 0 == strcmp(val->string, "v1"));
+    if (NULL != val) OBJ_RELEASE(val);
+
+    OBJ_RELEASE(dst);
+    OBJ_RELEASE(src);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_dup_public(void)
+{
+    opal_info_t *src = OBJ_NEW(opal_info_t);
+
+    /* public key (not internal) */
+    opal_info_set(src, "pub_key", "pub_val");
+    /* internal key -- dup_public() must SKIP it */
+    opal_info_set_internal(src, "int_key", "int_val");
+
+    /* opal_info_dup_public also requires caller-allocated *newinfo */
+    opal_info_t *dst = OBJ_NEW(opal_info_t);
+    int rc = opal_info_dup_public(src, &dst);
+    test_verify("opal_info_dup_public returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    int nkeys = -1;
+    opal_info_get_nkeys(dst, &nkeys);
+    test_verify("dup_public omits internal key (nkeys==1)", 1 == nkeys);
+
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    opal_info_get(dst, "pub_key", &val, &flag);
+    test_verify("dup_public copies public key", 1 == flag &&
+                NULL != val && 0 == strcmp(val->string, "pub_val"));
+    if (NULL != val) OBJ_RELEASE(val);
+
+    flag = 0;
+    opal_info_get(dst, "int_key", &val, &flag);
+    test_verify("dup_public does not copy internal key", 0 == flag);
+
+    OBJ_RELEASE(dst);
+    OBJ_RELEASE(src);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * opal_info_free() is declared in info.h but its implementation lives
+ * in the OMPI layer (not compiled in the OPAL unit test build).
+ * We cover the lifecycle via OBJ_NEW / OBJ_RELEASE, which is the
+ * canonical OPAL mechanism for freeing reference-counted objects.
+ * The test verifies that creating an info, populating it, and
+ * releasing it does not crash or leak references on the contained keys.
+ */
+static void test_free(void)
+{
+    opal_info_t *info = OBJ_NEW(opal_info_t);
+    opal_info_set(info, "k1", "v1");
+    opal_info_set(info, "k2", "v2");
+
+    /* Verify contents before release */
+    int nkeys = -1;
+    opal_info_get_nkeys(info, &nkeys);
+    test_verify("info has 2 keys before release", 2 == nkeys);
+
+    /* OBJ_RELEASE runs the destructor which removes all entries */
+    OBJ_RELEASE(info);
+
+    /*
+     * After OBJ_RELEASE the pointer value is undefined per the OPAL
+     * object model; we only verify no crash occurred (reaching here
+     * is the assertion).
+     */
+    test_verify("OBJ_RELEASE of info_t completed without crash", 1);
+}
diff --git a/test/util/opal_info_subscriber.c b/test/util/opal_info_subscriber.c
new file mode 100644
index 00000000000..bb83f8fbeb8
--- /dev/null
+++ b/test/util/opal_info_subscriber.c
@@ -0,0 +1,432 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2010 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2021 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2007-2018 Cisco Systems, Inc.  All rights reserved
+ * Copyright (c) 2012-2017 Los Alamos National Security, LLC. All rights
+ *                         reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal_infosubscriber_t -- the subscribe/notify
+ * infrastructure layered on top of opal_info_t.
+ *
+ * opal_infosubscriber_t has OBJ_CLASS_INSTANCE(opal_object_t, ...),
+ * so OBJ_NEW(opal_infosubscriber_t) works standalone without a
+ * subclass.
+ *
+ * Library is compiled with -DNDEBUG, so assert() is a no-op.
+ * All verification must go through test_verify().
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/info_subscriber.h"
+#include "opal/util/info.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* ------------------------------------------------------------------ */
+/* Callback infrastructure                                             */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Invocation counters, one per callback variant.  Reset before each
+ * test case that needs them.
+ */
+static int g_cb_invocations = 0;
+static const char *g_cb_last_key = NULL;
+static const char *g_cb_last_value = NULL;
+
+/*
+ * Simple pass-through callback: records arguments, returns value as-is.
+ * Must return a string literal (the impl never frees the return value).
+ */
+static const char *cb_passthrough(opal_infosubscriber_t *obj,
+                                  const char *key,
+                                  const char *value)
+{
+    (void) obj;
+    g_cb_invocations++;
+    g_cb_last_key   = key;
+    g_cb_last_value = value;
+    /* Return the value unchanged.  Static literals are safe here. */
+    return value;
+}
+
+/*
+ * Override callback: always returns "overridden" regardless of input.
+ */
+static int g_override_invocations = 0;
+
+static const char *cb_override(opal_infosubscriber_t *obj,
+                               const char *key,
+                               const char *value)
+{
+    (void) obj;
+    (void) key;
+    (void) value;
+    g_override_invocations++;
+    return "overridden";
+}
+
+/*
+ * Suppressing callback: returns NULL, which causes the key to be
+ * stored as internal (inaccessible to the public API).
+ */
+static int g_suppress_invocations = 0;
+
+static const char *cb_suppress(opal_infosubscriber_t *obj,
+                               const char *key,
+                               const char *value)
+{
+    (void) obj;
+    (void) key;
+    (void) value;
+    g_suppress_invocations++;
+    return NULL;
+}
+
+/* ------------------------------------------------------------------ */
+/* Forward declarations                                                */
+/* ------------------------------------------------------------------ */
+
+static void test_subscribe_fires_on_register(void);
+static void test_subscribe_uses_existing_info(void);
+static void test_change_info_fires_callback(void);
+static void test_change_info_no_callback_is_internal(void);
+static void test_override_callback(void);
+static void test_suppress_callback(void);
+static void test_multiple_subscriptions(void);
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    test_init("opal_infosubscriber_t");
+
+    opal_init_util(&argc, &argv);
+
+    test_subscribe_fires_on_register();
+    test_subscribe_uses_existing_info();
+    test_change_info_fires_callback();
+    test_change_info_no_callback_is_internal();
+    test_override_callback();
+    test_suppress_callback();
+    test_multiple_subscriptions();
+
+    int r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+/* Helper: read a value from obj->s_info by key; return 0 if missing  */
+/* ------------------------------------------------------------------ */
+static int read_sinfo(opal_infosubscriber_t *obj, const char *key,
+                      char *buf, size_t buflen)
+{
+    if (NULL == obj->s_info) {
+        return 0;
+    }
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    opal_info_get(obj->s_info, key, &val, &flag);
+    if (flag && NULL != val) {
+        snprintf(buf, buflen, "%s", val->string);
+        OBJ_RELEASE(val);
+        return 1;
+    }
+    return 0;
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * When opal_infosubscribe_subscribe is called, it immediately
+ * invokes the callback with the default_value (or the value already
+ * stored in s_info for that key, whichever applies).  Here s_info is
+ * empty, so the default "default_val" is passed to the callback.
+ */
+static void test_subscribe_fires_on_register(void)
+{
+    g_cb_invocations = 0;
+    g_cb_last_key    = NULL;
+    g_cb_last_value  = NULL;
+
+    opal_infosubscriber_t *obj = OBJ_NEW(opal_infosubscriber_t);
+
+    int rc = opal_infosubscribe_subscribe(obj, "mykey", "default_val", cb_passthrough);
+    test_verify("subscribe returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("callback invoked once on subscribe", 1 == g_cb_invocations);
+    test_verify("callback received correct key",
+                NULL != g_cb_last_key && 0 == strcmp(g_cb_last_key, "mykey"));
+    test_verify("callback received default value",
+                NULL != g_cb_last_value && 0 == strcmp(g_cb_last_value, "default_val"));
+
+    /* The returned value from the passthrough callback must be stored
+     * in s_info under "mykey". */
+    char buf[64] = {0};
+    int found = read_sinfo(obj, "mykey", buf, sizeof(buf));
+    test_verify("s_info populated after subscribe", 1 == found);
+    test_verify("s_info value matches callback return",
+                0 == strcmp(buf, "default_val"));
+
+    OBJ_RELEASE(obj);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * If s_info already has a value for the key when subscribe is called,
+ * the callback receives that existing value, not the default.
+ */
+static void test_subscribe_uses_existing_info(void)
+{
+    g_cb_invocations = 0;
+    g_cb_last_value  = NULL;
+
+    opal_infosubscriber_t *obj = OBJ_NEW(opal_infosubscriber_t);
+
+    /* Pre-populate s_info before subscribing */
+    if (NULL == obj->s_info) {
+        obj->s_info = OBJ_NEW(opal_info_t);
+    }
+    opal_info_set(obj->s_info, "prekey", "existing_val");
+
+    int rc = opal_infosubscribe_subscribe(obj, "prekey", "fallback", cb_passthrough);
+    test_verify("subscribe with pre-existing info returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("callback still fires once", 1 == g_cb_invocations);
+    test_verify("callback received existing value, not default",
+                NULL != g_cb_last_value && 0 == strcmp(g_cb_last_value, "existing_val"));
+
+    OBJ_RELEASE(obj);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * opal_infosubscribe_change_info: iterates new_info keys, calls
+ * subscribers for each key that has one, and stores the result.
+ */
+static void test_change_info_fires_callback(void)
+{
+    g_cb_invocations = 0;
+
+    opal_infosubscriber_t *obj = OBJ_NEW(opal_infosubscriber_t);
+
+    /* Subscribe first so the callback exists for "watched" */
+    opal_infosubscribe_subscribe(obj, "watched", "init", cb_passthrough);
+    /* Reset counter after the subscribe-time invocation */
+    g_cb_invocations = 0;
+
+    /* Build new_info with a value change for "watched" */
+    opal_info_t *new_info = OBJ_NEW(opal_info_t);
+    opal_info_set(new_info, "watched", "new_val");
+
+    int rc = opal_infosubscribe_change_info(obj, new_info);
+    test_verify("change_info returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("callback fired by change_info", 1 == g_cb_invocations);
+
+    /* The updated value must appear in s_info */
+    char buf[64] = {0};
+    int found = read_sinfo(obj, "watched", buf, sizeof(buf));
+    test_verify("s_info updated by change_info", 1 == found);
+    test_verify("s_info holds new value after change_info",
+                0 == strcmp(buf, "new_val"));
+
+    OBJ_RELEASE(new_info);
+    OBJ_RELEASE(obj);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * Keys that arrive via change_info with NO registered callback are
+ * stored via opal_info_set_internal (ie_internal=true).  At the OPAL
+ * layer, opal_info_get() finds the key regardless of ie_internal --
+ * info_find_key() matches purely on the key string.  So flag comes
+ * back 1.  The observable that discriminates internal from public keys
+ * is opal_info_dup_public(): it skips ie_internal entries.
+ *
+ * This test verifies:
+ *   1. The key is reachable via opal_info_get (flag==1).
+ *   2. opal_info_dup (copies all)    -> key present in duplicate.
+ *   3. opal_info_dup_public (public only) -> key absent in duplicate.
+ */
+static void test_change_info_no_callback_is_internal(void)
+{
+    opal_infosubscriber_t *obj = OBJ_NEW(opal_infosubscriber_t);
+
+    /* No subscription for "unwatched" -- stored as internal */
+    opal_info_t *new_info = OBJ_NEW(opal_info_t);
+    opal_info_set(new_info, "unwatched", "some_val");
+
+    opal_infosubscribe_change_info(obj, new_info);
+
+    /*
+     * opal_info_get at the OPAL layer does NOT filter by ie_internal.
+     * The key is present and flag==1.
+     */
+    opal_cstring_t *val = NULL;
+    int flag = 0;
+    opal_info_get(obj->s_info, "unwatched", &val, &flag);
+    test_verify("unsubscribed key is findable via opal_info_get (flag==1)",
+                1 == flag);
+    test_verify("unsubscribed key holds expected value",
+                NULL != val && 0 == strcmp(val->string, "some_val"));
+    if (NULL != val) {
+        OBJ_RELEASE(val);
+    }
+
+    /*
+     * opal_info_dup (all keys) must copy the internal key.
+     */
+    opal_info_t *dup_all = OBJ_NEW(opal_info_t);
+    opal_info_dup(obj->s_info, &dup_all);
+    int nkeys_all = -1;
+    opal_info_get_nkeys(dup_all, &nkeys_all);
+    test_verify("opal_info_dup copies internal key", 1 == nkeys_all);
+    OBJ_RELEASE(dup_all);
+
+    /*
+     * opal_info_dup_public (public keys only) must SKIP the internal key.
+     * This is the observable that proves the key was stored internally.
+     */
+    opal_info_t *dup_pub = OBJ_NEW(opal_info_t);
+    opal_info_dup_public(obj->s_info, &dup_pub);
+    int nkeys_pub = -1;
+    opal_info_get_nkeys(dup_pub, &nkeys_pub);
+    test_verify("opal_info_dup_public skips key stored via change_info (no callback)",
+                0 == nkeys_pub);
+    OBJ_RELEASE(dup_pub);
+
+    OBJ_RELEASE(new_info);
+    OBJ_RELEASE(obj);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * A callback that returns a different value overrides what gets
+ * stored in s_info.
+ */
+static void test_override_callback(void)
+{
+    g_override_invocations = 0;
+
+    opal_infosubscriber_t *obj = OBJ_NEW(opal_infosubscriber_t);
+    opal_infosubscribe_subscribe(obj, "k", "default", cb_override);
+    /* subscribe-time invocation already happened */
+    test_verify("override callback fired on subscribe", 1 == g_override_invocations);
+
+    /* s_info must hold the overridden value, not the default */
+    char buf[64] = {0};
+    int found = read_sinfo(obj, "k", buf, sizeof(buf));
+    test_verify("s_info holds overridden value after subscribe", 1 == found);
+    test_verify("overridden value is \"overridden\"", 0 == strcmp(buf, "overridden"));
+
+    /* A change_info must also produce the overridden value */
+    g_override_invocations = 0;
+    opal_info_t *new_info = OBJ_NEW(opal_info_t);
+    opal_info_set(new_info, "k", "user_val");
+
+    opal_infosubscribe_change_info(obj, new_info);
+    test_verify("override callback fires on change_info", 1 == g_override_invocations);
+
+    memset(buf, 0, sizeof(buf));
+    found = read_sinfo(obj, "k", buf, sizeof(buf));
+    test_verify("s_info still overridden after change_info", 1 == found);
+    test_verify("value still \"overridden\" after change_info",
+                0 == strcmp(buf, "overridden"));
+
+    OBJ_RELEASE(new_info);
+    OBJ_RELEASE(obj);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * A callback that returns NULL causes the key to be deleted from s_info
+ * (see info_subscriber.c: if (updated_value) set, else delete).
+ */
+static void test_suppress_callback(void)
+{
+    g_suppress_invocations = 0;
+
+    opal_infosubscriber_t *obj = OBJ_NEW(opal_infosubscriber_t);
+    opal_infosubscribe_subscribe(obj, "sk", "default_sk", cb_suppress);
+    test_verify("suppress callback fires on subscribe", 1 == g_suppress_invocations);
+
+    /* The key must NOT be present in s_info (callback returned NULL) */
+    char buf[64] = {0};
+    int found = read_sinfo(obj, "sk", buf, sizeof(buf));
+    test_verify("key absent from s_info when callback returns NULL", 0 == found);
+
+    OBJ_RELEASE(obj);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * Subscribe two different callbacks on two different keys; verify
+ * each fires independently via change_info.
+ */
+static void test_multiple_subscriptions(void)
+{
+    g_cb_invocations       = 0;
+    g_override_invocations = 0;
+
+    opal_infosubscriber_t *obj = OBJ_NEW(opal_infosubscriber_t);
+    opal_infosubscribe_subscribe(obj, "key_a", "a_default", cb_passthrough);
+    opal_infosubscribe_subscribe(obj, "key_b", "b_default", cb_override);
+
+    /* Reset after subscribe-time invocations */
+    g_cb_invocations       = 0;
+    g_override_invocations = 0;
+
+    opal_info_t *new_info = OBJ_NEW(opal_info_t);
+    opal_info_set(new_info, "key_a", "new_a");
+    opal_info_set(new_info, "key_b", "new_b");
+
+    opal_infosubscribe_change_info(obj, new_info);
+
+    test_verify("passthrough callback fired for key_a", 1 == g_cb_invocations);
+    test_verify("override callback fired for key_b", 1 == g_override_invocations);
+
+    char buf[64] = {0};
+    int found = read_sinfo(obj, "key_a", buf, sizeof(buf));
+    test_verify("key_a holds passthrough value", 1 == found &&
+                0 == strcmp(buf, "new_a"));
+
+    memset(buf, 0, sizeof(buf));
+    found = read_sinfo(obj, "key_b", buf, sizeof(buf));
+    test_verify("key_b holds overridden value", 1 == found &&
+                0 == strcmp(buf, "overridden"));
+
+    OBJ_RELEASE(new_info);
+    OBJ_RELEASE(obj);
+}
diff --git a/test/util/opal_json.c b/test/util/opal_json.c
index 3cee3442e23..0569a8eb6d7 100644
--- a/test/util/opal_json.c
+++ b/test/util/opal_json.c
@@ -10,6 +10,7 @@
  */
 
 #include "opal_config.h"
+#include "opal/constants.h"
 #include "opal/util/json/opal_json.h"
 #include "opal/runtime/opal.h"
 #include "support.h"
@@ -264,9 +265,9 @@ static void test_invalid_json_string(void)
 
 int main(int argc, char **argv)
 {
-
-    opal_init(&argc, &argv);
+    int rc = opal_init(&argc, &argv);
     test_init("opal_util_json");
+    test_verify("opal_init() succeeds", OPAL_SUCCESS == rc);
     test_valid_json();
     test_invalid_json_string();
     opal_finalize();
diff --git a/test/util/opal_keyval_parse.c b/test/util/opal_keyval_parse.c
new file mode 100644
index 00000000000..db844b5aef1
--- /dev/null
+++ b/test/util/opal_keyval_parse.c
@@ -0,0 +1,438 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal/util/keyval_parse.c.
+ *
+ * Tests: opal_util_keyval_parse (with various file formats).
+ *
+ * Note: assert() in the library may be a no-op (when built with -DNDEBUG)
+ * or active (otherwise), so this test's verification must go through
+ * test_verify() rather than relying on assert().
+ *
+ * Callback note: the keyval_parse.h header states that key and value
+ * are "pointers into static buffers" that "may be overwritten
+ * immediately after the callback returns."  Therefore the callback
+ * MUST copy the strings before returning.
+ *
+ * Lexer token notes (from keyval_lex.l):
+ *   CHAR = [A-Za-z0-9_\-\.]
+ *   A line "key = value\n" produces SINGLE_WORD → parse_line() →
+ *     callback(key, value) with key and value as lexed (no prefix
+ *     stripping).  So "mca_foo = bar" → callback("mca_foo", "bar").
+ *
+ *   A line "-mca foo bar\n" produces MCAVAR → parse_line_new() with
+ *     trim_name(key_buffer, "-mca", NULL) / trim_name(key_buffer,
+ *     "--mca", NULL).  The lex token text is the whole "-mca foo" span
+ *     (lexer rule: "-"?"-mca"{WHITE}+{CHAR}+{WHITE}+); after trimming
+ *     "-mca" and leading/trailing whitespace the key becomes "foo".
+ *
+ *   Comment lines ("#..." or "//...") return NEWLINE → zero callbacks.
+ *
+ * Do NOT call opal_util_keyval_parse_init() from this test:
+ * opal_init_util() (via opal_init_core.c) already calls it exactly once.
+ * A second call re-registers the cleanup and re-constructs keyval_mutex,
+ * so opal_finalize_util() then OBJ_DESTRUCTs the mutex twice -- which
+ * aborts on the OBJ magic-id assertion in builds with assertions enabled
+ * (i.e. without -DNDEBUG, as on some CI platforms).
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/keyval_parse.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* ------------------------------------------------------------------ */
+/* callback recording infrastructure                                   */
+/* ------------------------------------------------------------------ */
+
+#define MAX_PAIRS 32
+
+typedef struct {
+    char *key;
+    char *value; /* NULL when the parser provided NULL value */
+} kv_pair_t;
+
+static kv_pair_t g_pairs[MAX_PAIRS];
+static int       g_npairs;
+
+static void reset_pairs(void)
+{
+    int i;
+    for (i = 0; i < g_npairs; ++i) {
+        free(g_pairs[i].key);
+        free(g_pairs[i].value);
+        g_pairs[i].key   = NULL;
+        g_pairs[i].value = NULL;
+    }
+    g_npairs = 0;
+}
+
+static void record_callback(const char *key, const char *value)
+{
+    if (g_npairs >= MAX_PAIRS) {
+        return;
+    }
+    /* The buffers are static inside the parser -- must strdup. */
+    g_pairs[g_npairs].key   = (NULL != key)   ? strdup(key)   : NULL;
+    g_pairs[g_npairs].value = (NULL != value)  ? strdup(value) : NULL;
+    ++g_npairs;
+}
+
+/*
+ * Write 'content' to a temp file.  Fills 'tmppath' (must be >= 64 bytes)
+ * with the path on success.  Returns 0 on success, -1 on failure.
+ */
+static int write_temp_file(char *tmppath, size_t bufsz, const char *content)
+{
+    int fd;
+    FILE *fp;
+
+    snprintf(tmppath, bufsz, "/tmp/opal_keyval_test_XXXXXX");
+    fd = mkstemp(tmppath);
+    if (-1 == fd) {
+        return -1;
+    }
+    fp = fdopen(fd, "w");
+    if (NULL == fp) {
+        close(fd);
+        return -1;
+    }
+    fputs(content, fp);
+    fclose(fp);
+    return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_util_keyval_parse: plain key = value lines                     */
+/* ------------------------------------------------------------------ */
+
+static void test_parse_basic(void)
+{
+    char tmppath[64];
+    int rc;
+
+    /* File with two plain key = value lines and a blank line. */
+    const char *content =
+        "key1 = value1\n"
+        "\n"
+        "key2 = value2\n";
+
+    if (0 != write_temp_file(tmppath, sizeof(tmppath), content)) {
+        test_failure("test_parse_basic: could not create temp file");
+        return;
+    }
+
+    reset_pairs();
+    rc = opal_util_keyval_parse(tmppath, record_callback);
+    unlink(tmppath);
+
+    test_verify("parse_basic: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("parse_basic: 2 pairs recorded", 2 == g_npairs);
+
+    if (2 == g_npairs) {
+        test_verify("parse_basic: pair[0].key == 'key1'",
+                    NULL != g_pairs[0].key &&
+                    0 == strcmp("key1", g_pairs[0].key));
+        test_verify("parse_basic: pair[0].value == 'value1'",
+                    NULL != g_pairs[0].value &&
+                    0 == strcmp("value1", g_pairs[0].value));
+
+        test_verify("parse_basic: pair[1].key == 'key2'",
+                    NULL != g_pairs[1].key &&
+                    0 == strcmp("key2", g_pairs[1].key));
+        test_verify("parse_basic: pair[1].value == 'value2'",
+                    NULL != g_pairs[1].value &&
+                    0 == strcmp("value2", g_pairs[1].value));
+    }
+
+    reset_pairs();
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_util_keyval_parse: mca-prefixed key = value                   */
+/* ------------------------------------------------------------------ */
+
+static void test_parse_mca_prefix(void)
+{
+    char tmppath[64];
+    int rc;
+
+    /*
+     * A line "mca_foo = bar" uses CHAR tokens and the plain "=" path,
+     * so it goes through parse_line().  The key received by the callback
+     * is the literal lexed token "mca_foo" (no prefix stripping occurs
+     * in parse_line).
+     */
+    const char *content =
+        "mca_foo = bar\n"
+        "mca_btl = tcp\n";
+
+    if (0 != write_temp_file(tmppath, sizeof(tmppath), content)) {
+        test_failure("test_parse_mca_prefix: could not create temp file");
+        return;
+    }
+
+    reset_pairs();
+    rc = opal_util_keyval_parse(tmppath, record_callback);
+    unlink(tmppath);
+
+    test_verify("parse_mca_prefix: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("parse_mca_prefix: 2 pairs recorded", 2 == g_npairs);
+
+    if (2 == g_npairs) {
+        test_verify("parse_mca_prefix: pair[0].key == 'mca_foo'",
+                    NULL != g_pairs[0].key &&
+                    0 == strcmp("mca_foo", g_pairs[0].key));
+        test_verify("parse_mca_prefix: pair[0].value == 'bar'",
+                    NULL != g_pairs[0].value &&
+                    0 == strcmp("bar", g_pairs[0].value));
+
+        test_verify("parse_mca_prefix: pair[1].key == 'mca_btl'",
+                    NULL != g_pairs[1].key &&
+                    0 == strcmp("mca_btl", g_pairs[1].key));
+        test_verify("parse_mca_prefix: pair[1].value == 'tcp'",
+                    NULL != g_pairs[1].value &&
+                    0 == strcmp("tcp", g_pairs[1].value));
+    }
+
+    reset_pairs();
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_util_keyval_parse: comment lines produce zero callbacks        */
+/* ------------------------------------------------------------------ */
+
+static void test_parse_comments(void)
+{
+    char tmppath[64];
+    int rc;
+
+    /* Only comment and blank lines: no callbacks expected. */
+    const char *content =
+        "# This is a comment\n"
+        "// Another comment\n"
+        "\n"
+        "# More comments\n";
+
+    if (0 != write_temp_file(tmppath, sizeof(tmppath), content)) {
+        test_failure("test_parse_comments: could not create temp file");
+        return;
+    }
+
+    reset_pairs();
+    rc = opal_util_keyval_parse(tmppath, record_callback);
+    unlink(tmppath);
+
+    test_verify("parse_comments: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("parse_comments: 0 pairs recorded", 0 == g_npairs);
+
+    reset_pairs();
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_util_keyval_parse: mixed content                               */
+/* ------------------------------------------------------------------ */
+
+static void test_parse_mixed(void)
+{
+    char tmppath[64];
+    int rc;
+
+    /* Mix of comments, blank lines, and real key=value pairs. */
+    const char *content =
+        "# top comment\n"
+        "\n"
+        "alpha = one\n"
+        "# middle comment\n"
+        "beta = two\n"
+        "\n"
+        "gamma = three\n";
+
+    if (0 != write_temp_file(tmppath, sizeof(tmppath), content)) {
+        test_failure("test_parse_mixed: could not create temp file");
+        return;
+    }
+
+    reset_pairs();
+    rc = opal_util_keyval_parse(tmppath, record_callback);
+    unlink(tmppath);
+
+    test_verify("parse_mixed: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("parse_mixed: 3 pairs recorded", 3 == g_npairs);
+
+    if (3 == g_npairs) {
+        test_verify("parse_mixed: pair[0].key == 'alpha'",
+                    NULL != g_pairs[0].key &&
+                    0 == strcmp("alpha", g_pairs[0].key));
+        test_verify("parse_mixed: pair[0].value == 'one'",
+                    NULL != g_pairs[0].value &&
+                    0 == strcmp("one", g_pairs[0].value));
+
+        test_verify("parse_mixed: pair[1].key == 'beta'",
+                    NULL != g_pairs[1].key &&
+                    0 == strcmp("beta", g_pairs[1].key));
+        test_verify("parse_mixed: pair[1].value == 'two'",
+                    NULL != g_pairs[1].value &&
+                    0 == strcmp("two", g_pairs[1].value));
+
+        test_verify("parse_mixed: pair[2].key == 'gamma'",
+                    NULL != g_pairs[2].key &&
+                    0 == strcmp("gamma", g_pairs[2].key));
+        test_verify("parse_mixed: pair[2].value == 'three'",
+                    NULL != g_pairs[2].value &&
+                    0 == strcmp("three", g_pairs[2].value));
+    }
+
+    reset_pairs();
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_util_keyval_parse: nonexistent file                            */
+/* ------------------------------------------------------------------ */
+
+static void test_parse_nonexistent(void)
+{
+    int rc;
+    const char *nonexistent = "/tmp/opal_keyval_test_file_that_does_not_exist_xyzzy";
+
+    reset_pairs();
+    rc = opal_util_keyval_parse(nonexistent, record_callback);
+
+    test_verify("parse_nonexistent: returns OPAL_ERR_NOT_FOUND",
+                OPAL_ERR_NOT_FOUND == rc);
+    test_verify("parse_nonexistent: 0 callbacks", 0 == g_npairs);
+
+    reset_pairs();
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_util_keyval_parse: key with no value (empty after =)          */
+/* ------------------------------------------------------------------ */
+
+static void test_parse_empty_value(void)
+{
+    char tmppath[64];
+    int rc;
+
+    /*
+     * A line "key =" with nothing after the '=' (only newline) causes
+     * the VALUE start condition to see {WHITE}*\n → NEWLINE.
+     * parse_line() then calls keyval_callback(key_buffer, NULL).
+     */
+    const char *content = "mykey =\n";
+
+    if (0 != write_temp_file(tmppath, sizeof(tmppath), content)) {
+        test_failure("test_parse_empty_value: could not create temp file");
+        return;
+    }
+
+    reset_pairs();
+    rc = opal_util_keyval_parse(tmppath, record_callback);
+    unlink(tmppath);
+
+    test_verify("parse_empty_value: returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("parse_empty_value: 1 pair recorded", 1 == g_npairs);
+
+    if (1 == g_npairs) {
+        test_verify("parse_empty_value: key == 'mykey'",
+                    NULL != g_pairs[0].key &&
+                    0 == strcmp("mykey", g_pairs[0].key));
+        /* Value is NULL for empty right-hand side. */
+        test_verify("parse_empty_value: value is NULL",
+                    NULL == g_pairs[0].value);
+    }
+
+    reset_pairs();
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_util_keyval_parse: whitespace-padded values                   */
+/* ------------------------------------------------------------------ */
+
+static void test_parse_whitespace_value(void)
+{
+    char tmppath[64];
+    int rc;
+
+    /*
+     * The VALUE lex rule is:
+     *   <VALUE>[^\n]*[^\t \n]/[\t ]*  -> OPAL_UTIL_KEYVAL_PARSE_VALUE
+     * This captures everything up to (but not including) trailing
+     * whitespace.  So "key = hello world" produces value "hello world"
+     * (internal spaces preserved, trailing spaces stripped).
+     */
+    const char *content = "key = hello world\n";
+
+    if (0 != write_temp_file(tmppath, sizeof(tmppath), content)) {
+        test_failure("test_parse_whitespace_value: could not create temp file");
+        return;
+    }
+
+    reset_pairs();
+    rc = opal_util_keyval_parse(tmppath, record_callback);
+    unlink(tmppath);
+
+    test_verify("parse_whitespace_value: returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    test_verify("parse_whitespace_value: 1 pair recorded", 1 == g_npairs);
+
+    if (1 == g_npairs) {
+        test_verify("parse_whitespace_value: key == 'key'",
+                    NULL != g_pairs[0].key &&
+                    0 == strcmp("key", g_pairs[0].key));
+        test_verify("parse_whitespace_value: value == 'hello world'",
+                    NULL != g_pairs[0].value &&
+                    0 == strcmp("hello world", g_pairs[0].value));
+    }
+
+    reset_pairs();
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    opal_init_util(&argc, &argv);
+    test_init("opal_keyval_parse");
+
+    test_parse_basic();
+    test_parse_mca_prefix();
+    test_parse_comments();
+    test_parse_mixed();
+    test_parse_nonexistent();
+    test_parse_empty_value();
+    test_parse_whitespace_value();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_malloc.c b/test/util/opal_malloc.c
new file mode 100644
index 00000000000..f343a0999d1
--- /dev/null
+++ b/test/util/opal_malloc.c
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for the opal_malloc / opal_calloc / opal_realloc / opal_free
+ * family and opal_malloc_debug().
+ *
+ * NOTE: malloc.h explicitly states these are back-end functions intended to
+ * be called with __FILE__ and __LINE__ by a front-end macro.  The tests call
+ * them directly with those literal arguments, which is the documented
+ * interface.
+ *
+ * NOTE: opal_malloc_debug() only changes observable state when
+ * OPAL_ENABLE_DEBUG is defined; in non-debug builds the call is a no-op.
+ * We therefore only test that allocations continue to succeed after calling
+ * it, not that it alters any internal diagnostic output.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/malloc.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+/* ------------------------------------------------------------------ */
+/* helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+/* Canary bytes we write into allocated memory to verify access. */
+#define CANARY_BYTE 0xAB
+#define ALLOC_SIZE  128
+
+static void test_malloc_basic(void)
+{
+    void *p = opal_malloc(ALLOC_SIZE, __FILE__, __LINE__);
+    test_verify("opal_malloc returns non-NULL", NULL != p);
+    if (NULL != p) {
+        /* write and read back to prove the memory is usable */
+        memset(p, CANARY_BYTE, ALLOC_SIZE);
+        test_verify("opal_malloc memory is writable/readable",
+                    (unsigned char) CANARY_BYTE == ((unsigned char *)p)[0]);
+        test_verify("opal_malloc memory last byte ok",
+                    (unsigned char) CANARY_BYTE == ((unsigned char *)p)[ALLOC_SIZE - 1]);
+        opal_free(p, __FILE__, __LINE__);
+    }
+}
+
+static void test_calloc_zeroes(void)
+{
+    size_t n = 16;
+    size_t sz = sizeof(int);
+    int i;
+    int all_zero;
+
+    void *p = opal_calloc(n, sz, __FILE__, __LINE__);
+    test_verify("opal_calloc returns non-NULL", NULL != p);
+    if (NULL != p) {
+        all_zero = 1;
+        for (i = 0; i < (int)(n * sz); ++i) {
+            if (0 != ((unsigned char *)p)[i]) {
+                all_zero = 0;
+                break;
+            }
+        }
+        test_verify("opal_calloc zeroes all bytes", all_zero);
+        opal_free(p, __FILE__, __LINE__);
+    }
+}
+
+static void test_realloc_grow(void)
+{
+    /* Allocate a small block, write a pattern, then grow it.
+     * The leading bytes must be preserved by realloc. */
+    size_t small = 8;
+    size_t large = 256;
+    void *p;
+    void *q;
+    int i;
+    int prefix_ok;
+
+    p = opal_malloc(small, __FILE__, __LINE__);
+    test_verify("realloc_grow: initial malloc non-NULL", NULL != p);
+    if (NULL == p) {
+        return;
+    }
+    for (i = 0; i < (int)small; ++i) {
+        ((unsigned char *)p)[i] = (unsigned char)(i + 1);
+    }
+
+    q = opal_realloc(p, large, __FILE__, __LINE__);
+    test_verify("realloc_grow: returns non-NULL", NULL != q);
+    if (NULL != q) {
+        prefix_ok = 1;
+        for (i = 0; i < (int)small; ++i) {
+            if ((unsigned char)(i + 1) != ((unsigned char *)q)[i]) {
+                prefix_ok = 0;
+                break;
+            }
+        }
+        test_verify("realloc_grow: old prefix bytes preserved", prefix_ok);
+        opal_free(q, __FILE__, __LINE__);
+    } else {
+        /* p is still valid when realloc fails; free it */
+        opal_free(p, __FILE__, __LINE__);
+    }
+}
+
+static void test_realloc_shrink(void)
+{
+    size_t large = 512;
+    size_t small = 4;
+    void *p;
+    void *q;
+    int i;
+    int prefix_ok;
+
+    p = opal_malloc(large, __FILE__, __LINE__);
+    test_verify("realloc_shrink: initial malloc non-NULL", NULL != p);
+    if (NULL == p) {
+        return;
+    }
+    for (i = 0; i < (int)large; ++i) {
+        ((unsigned char *)p)[i] = 0xFF;
+    }
+
+    q = opal_realloc(p, small, __FILE__, __LINE__);
+    test_verify("realloc_shrink: returns non-NULL", NULL != q);
+    if (NULL != q) {
+        /* first 'small' bytes must still be 0xFF */
+        prefix_ok = 1;
+        for (i = 0; i < (int)small; ++i) {
+            if (0xFF != ((unsigned char *)q)[i]) {
+                prefix_ok = 0;
+                break;
+            }
+        }
+        test_verify("realloc_shrink: retained bytes intact", prefix_ok);
+        opal_free(q, __FILE__, __LINE__);
+    } else {
+        opal_free(p, __FILE__, __LINE__);
+    }
+}
+
+/*
+ * test_malloc_debug_does_not_break_alloc
+ *
+ * opal_malloc_debug() is a no-op in non-debug builds; in debug builds
+ * it adjusts an internal diagnostic level.  In either case allocations
+ * must succeed afterwards.
+ */
+static void test_malloc_debug_does_not_break_alloc(void)
+{
+    void *p;
+
+    opal_malloc_debug(0);
+    p = opal_malloc(64, __FILE__, __LINE__);
+    test_verify("after opal_malloc_debug(0): malloc succeeds", NULL != p);
+    if (NULL != p) {
+        opal_free(p, __FILE__, __LINE__);
+    }
+
+    opal_malloc_debug(1);
+    p = opal_malloc(64, __FILE__, __LINE__);
+    test_verify("after opal_malloc_debug(1): malloc succeeds", NULL != p);
+    if (NULL != p) {
+        opal_free(p, __FILE__, __LINE__);
+    }
+
+    opal_malloc_debug(2);
+    p = opal_malloc(64, __FILE__, __LINE__);
+    test_verify("after opal_malloc_debug(2): malloc succeeds", NULL != p);
+    if (NULL != p) {
+        opal_free(p, __FILE__, __LINE__);
+    }
+}
+
+static void test_free_null_is_safe(void)
+{
+    void *p;
+
+    /* opal_free maps directly to free(); passing NULL is defined in C
+     * to be a no-op.  Rather than assert a constant, verify the wrapper
+     * adds no unexpected behavior by confirming the allocator is still
+     * functional after the NULL free -- an observable condition. */
+    opal_free(NULL, __FILE__, __LINE__);
+
+    p = opal_malloc(32, __FILE__, __LINE__);
+    test_verify("opal_malloc still works after opal_free(NULL)", NULL != p);
+    if (NULL != p) {
+        opal_free(p, __FILE__, __LINE__);
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    test_init("opal_malloc");
+
+    opal_init_util(&argc, &argv);
+
+    test_malloc_basic();
+    test_calloc_zeroes();
+    test_realloc_grow();
+    test_realloc_shrink();
+    test_malloc_debug_does_not_break_alloc();
+    test_free_null_is_safe();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_net.c b/test/util/opal_net.c
new file mode 100644
index 00000000000..43734c1b9fa
--- /dev/null
+++ b/test/util/opal_net.c
@@ -0,0 +1,591 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal/util/net.h — IPv4/IPv6 address helpers.
+ *
+ * All inputs are constructed from literal constants so the tests are
+ * fully deterministic and independent of runtime DNS or network state.
+ *
+ * Init order (mandatory):
+ *   opal_init_util()  -- registers MCA parameters including
+ *                        opal_net_private_ipv4 with its default value
+ *                        "10.0.0.0/8;172.16.0.0/12;192.168.0.0/16;169.254.0.0/16"
+ *   opal_net_init()   -- parses that string and fills the private_ipv4
+ *                        table (without this, addr_isipv4public returns
+ *                        true for everything -- see net.c line ~314)
+ *
+ * NOTE: -DNDEBUG is set; assert() is a no-op.  All verification MUST
+ * use test_verify() / test_failure().  Never use assert().
+ *
+ * NOTE: opal_net_get_hostname() returns a per-thread static buffer
+ * that must NOT be freed.
+ *
+ * NOTE: We skip /0 and /32 in prefix2netmask tests because the
+ * underlying computation uses (1u << 32) which is undefined behaviour
+ * in C; any value produced is non-deterministic on untested hardware.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/net.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+/* ------------------------------------------------------------------ */
+/* Helpers to build sockaddr structs from literal strings              */
+/* ------------------------------------------------------------------ */
+
+static struct sockaddr_in
+make_sin(const char *dotquad, uint16_t port_host_order)
+{
+    struct sockaddr_in sin;
+    memset(&sin, 0, sizeof(sin));
+    sin.sin_family = AF_INET;
+    sin.sin_port   = htons(port_host_order);
+    inet_pton(AF_INET, dotquad, &sin.sin_addr);
+    return sin;
+}
+
+#if OPAL_ENABLE_IPV6
+static struct sockaddr_in6
+make_sin6(const char *addr_str, uint16_t port_host_order)
+{
+    struct sockaddr_in6 sin6;
+    memset(&sin6, 0, sizeof(sin6));
+    sin6.sin6_family = AF_INET6;
+    sin6.sin6_port   = htons(port_host_order);
+    inet_pton(AF_INET6, addr_str, &sin6.sin6_addr);
+    return sin6;
+}
+#endif /* OPAL_ENABLE_IPV6 */
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_isaddr                                               */
+/* ------------------------------------------------------------------ */
+
+static void
+test_isaddr(void)
+{
+    /* Valid IPv4 dotted-quad */
+    test_verify("opal_net_isaddr(\"127.0.0.1\") is true",
+                opal_net_isaddr("127.0.0.1"));
+    test_verify("opal_net_isaddr(\"192.168.1.100\") is true",
+                opal_net_isaddr("192.168.1.100"));
+    test_verify("opal_net_isaddr(\"8.8.8.8\") is true",
+                opal_net_isaddr("8.8.8.8"));
+
+#if OPAL_ENABLE_IPV6
+    /* Valid IPv6 literals */
+    test_verify("opal_net_isaddr(\"::1\") is true",
+                opal_net_isaddr("::1"));
+    test_verify("opal_net_isaddr(\"fe80::1\") is true",
+                opal_net_isaddr("fe80::1"));
+    test_verify("opal_net_isaddr(\"2001:db8::1\") is true",
+                opal_net_isaddr("2001:db8::1"));
+#endif /* OPAL_ENABLE_IPV6 */
+
+    /* Hostnames -- NOT numeric addresses */
+    test_verify("opal_net_isaddr(\"localhost\") is false",
+                !opal_net_isaddr("localhost"));
+    test_verify("opal_net_isaddr(\"example.com\") is false",
+                !opal_net_isaddr("example.com"));
+    test_verify("opal_net_isaddr(\"\") is false",
+                !opal_net_isaddr(""));
+    test_verify("opal_net_isaddr(\"not_an_address\") is false",
+                !opal_net_isaddr("not_an_address"));
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_prefix2netmask                                       */
+/*                                                                     */
+/* The function returns htonl(((1u<<prefixlen)-1u) << (32-prefixlen)) */
+/* i.e. the result is in NETWORK byte order.  We compare by applying  */
+/* the same htonl() to our host-order expected values.                */
+/*                                                                     */
+/* We deliberately SKIP /0 and /32: both trigger shift-by-32 UB.      */
+/* ------------------------------------------------------------------ */
+
+static void
+test_prefix2netmask(void)
+{
+    /* /8  -> 0xFF000000 host-order */
+    test_verify("prefix2netmask(8) == htonl(0xFF000000)",
+                htonl(0xFF000000u) == opal_net_prefix2netmask(8));
+
+    /* /16 -> 0xFFFF0000 host-order */
+    test_verify("prefix2netmask(16) == htonl(0xFFFF0000)",
+                htonl(0xFFFF0000u) == opal_net_prefix2netmask(16));
+
+    /* /24 -> 0xFFFFFF00 host-order */
+    test_verify("prefix2netmask(24) == htonl(0xFFFFFF00)",
+                htonl(0xFFFFFF00u) == opal_net_prefix2netmask(24));
+
+    /* /1  -> 0x80000000 host-order */
+    test_verify("prefix2netmask(1) == htonl(0x80000000)",
+                htonl(0x80000000u) == opal_net_prefix2netmask(1));
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_islocalhost                                          */
+/* ------------------------------------------------------------------ */
+
+static void
+test_islocalhost(void)
+{
+    /* 127.0.0.1 */
+    {
+        struct sockaddr_in sin = make_sin("127.0.0.1", 0);
+        test_verify("opal_net_islocalhost(127.0.0.1) is true",
+                    opal_net_islocalhost((struct sockaddr *) &sin));
+    }
+
+    /* 127.0.0.2 -- still in 127.0.0.0/8 */
+    {
+        struct sockaddr_in sin = make_sin("127.0.0.2", 0);
+        test_verify("opal_net_islocalhost(127.0.0.2) is true",
+                    opal_net_islocalhost((struct sockaddr *) &sin));
+    }
+
+    /* 127.255.255.255 -- still in 127.0.0.0/8 */
+    {
+        struct sockaddr_in sin = make_sin("127.255.255.255", 0);
+        test_verify("opal_net_islocalhost(127.255.255.255) is true",
+                    opal_net_islocalhost((struct sockaddr *) &sin));
+    }
+
+    /* 128.0.0.1 -- just outside 127.0.0.0/8 */
+    {
+        struct sockaddr_in sin = make_sin("128.0.0.1", 0);
+        test_verify("opal_net_islocalhost(128.0.0.1) is false",
+                    !opal_net_islocalhost((struct sockaddr *) &sin));
+    }
+
+    /* 192.168.1.1 -- private but not loopback */
+    {
+        struct sockaddr_in sin = make_sin("192.168.1.1", 0);
+        test_verify("opal_net_islocalhost(192.168.1.1) is false",
+                    !opal_net_islocalhost((struct sockaddr *) &sin));
+    }
+
+    /* 8.8.8.8 -- public, definitely not localhost */
+    {
+        struct sockaddr_in sin = make_sin("8.8.8.8", 0);
+        test_verify("opal_net_islocalhost(8.8.8.8) is false",
+                    !opal_net_islocalhost((struct sockaddr *) &sin));
+    }
+
+    /*
+     * Regression guard for the 255.0.0.0 bug (now fixed in opal/util/net.c):
+     * the check previously masked only bit 7 of the top byte
+     * (0x7F000000 == (0x7F000000 & ntohl(s_addr))), so 255.x.x.x
+     * (0xFF000000) also matched as localhost.  It now masks the full top
+     * byte (0xFF000000 == (0xFF000000 & ntohl(s_addr))), so 255.0.0.0 is
+     * correctly not localhost, per the "127.0.0.0/8" contract.
+     */
+    {
+        struct sockaddr_in sin = make_sin("255.0.0.0", 0);
+        test_verify("opal_net_islocalhost(255.0.0.0) is false",
+                    !opal_net_islocalhost((struct sockaddr *) &sin));
+    }
+
+#if OPAL_ENABLE_IPV6
+    /* ::1 is the IPv6 loopback */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("::1", 0);
+        test_verify("opal_net_islocalhost(::1) is true",
+                    opal_net_islocalhost((struct sockaddr *) &sin6));
+    }
+
+    /* fe80::1 is link-local, not loopback */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("fe80::1", 0);
+        test_verify("opal_net_islocalhost(fe80::1) is false",
+                    !opal_net_islocalhost((struct sockaddr *) &sin6));
+    }
+
+    /* 2001:db8::1 is a documentation prefix, not loopback */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("2001:db8::1", 0);
+        test_verify("opal_net_islocalhost(2001:db8::1) is false",
+                    !opal_net_islocalhost((struct sockaddr *) &sin6));
+    }
+#endif /* OPAL_ENABLE_IPV6 */
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_samenetwork                                          */
+/* ------------------------------------------------------------------ */
+
+static void
+test_samenetwork(void)
+{
+    /* Two addresses on the same /24 */
+    {
+        struct sockaddr_in a = make_sin("192.168.1.10", 0);
+        struct sockaddr_in b = make_sin("192.168.1.20", 0);
+        test_verify("samenetwork: 192.168.1.x/24 match",
+                    opal_net_samenetwork((struct sockaddr *) &a,
+                                        (struct sockaddr *) &b, 24));
+    }
+
+    /* Two addresses on different /24 subnets */
+    {
+        struct sockaddr_in a = make_sin("192.168.1.10", 0);
+        struct sockaddr_in b = make_sin("192.168.2.10", 0);
+        test_verify("samenetwork: 192.168.1.x vs 192.168.2.x /24 differ",
+                    !opal_net_samenetwork((struct sockaddr *) &a,
+                                         (struct sockaddr *) &b, 24));
+    }
+
+    /* Same /16, different /24 -> still same network at /16 */
+    {
+        struct sockaddr_in a = make_sin("10.1.1.5", 0);
+        struct sockaddr_in b = make_sin("10.1.200.5", 0);
+        test_verify("samenetwork: 10.1.x.x/16 match",
+                    opal_net_samenetwork((struct sockaddr *) &a,
+                                        (struct sockaddr *) &b, 16));
+    }
+
+    /* Same /16, different /24 -> different at /24 */
+    {
+        struct sockaddr_in a = make_sin("10.1.1.5", 0);
+        struct sockaddr_in b = make_sin("10.1.200.5", 0);
+        test_verify("samenetwork: 10.1.1.x vs 10.1.200.x /24 differ",
+                    !opal_net_samenetwork((struct sockaddr *) &a,
+                                         (struct sockaddr *) &b, 24));
+    }
+
+    /* Different families must not be the same network */
+#if OPAL_ENABLE_IPV6
+    {
+        struct sockaddr_in  a4  = make_sin("127.0.0.1", 0);
+        struct sockaddr_in6 a6  = make_sin6("::1", 0);
+        test_verify("samenetwork: AF_INET vs AF_INET6 is always false",
+                    !opal_net_samenetwork((struct sockaddr *) &a4,
+                                         (struct sockaddr *) &a6, 8));
+    }
+
+    /* Two IPv6 addresses in the same /64 prefix */
+    {
+        struct sockaddr_in6 a = make_sin6("2001:db8::1", 0);
+        struct sockaddr_in6 b = make_sin6("2001:db8::2", 0);
+        test_verify("samenetwork: 2001:db8::/64 match",
+                    opal_net_samenetwork((struct sockaddr *) &a,
+                                        (struct sockaddr *) &b, 64));
+    }
+
+    /* Two IPv6 addresses in different /64 prefixes */
+    {
+        struct sockaddr_in6 a = make_sin6("2001:db8:1::1", 0);
+        struct sockaddr_in6 b = make_sin6("2001:db8:2::1", 0);
+        test_verify("samenetwork: 2001:db8:1:: vs 2001:db8:2:: /64 differ",
+                    !opal_net_samenetwork((struct sockaddr *) &a,
+                                         (struct sockaddr *) &b, 64));
+    }
+#endif /* OPAL_ENABLE_IPV6 */
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_addr_isipv4public                                    */
+/*                                                                     */
+/* The default opal_net_private_ipv4 (set in opal_params_core.c) is:  */
+/*   "10.0.0.0/8;172.16.0.0/12;192.168.0.0/16;169.254.0.0/16"        */
+/* After opal_net_init() these are loaded, so RFC1918 addrs return    */
+/* false and public addresses return true.                             */
+/* ------------------------------------------------------------------ */
+
+static void
+test_addr_isipv4public(void)
+{
+    /* Google DNS -- unambiguously public */
+    {
+        struct sockaddr_in sin = make_sin("8.8.8.8", 0);
+        test_verify("opal_net_addr_isipv4public(8.8.8.8) is true",
+                    opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 1.1.1.1 -- Cloudflare DNS, public */
+    {
+        struct sockaddr_in sin = make_sin("1.1.1.1", 0);
+        test_verify("opal_net_addr_isipv4public(1.1.1.1) is true",
+                    opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 10.0.0.1 -- RFC1918 private (10.0.0.0/8) */
+    {
+        struct sockaddr_in sin = make_sin("10.0.0.1", 0);
+        test_verify("opal_net_addr_isipv4public(10.0.0.1) is false (RFC1918)",
+                    !opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 10.255.255.255 -- still in 10.0.0.0/8 */
+    {
+        struct sockaddr_in sin = make_sin("10.255.255.255", 0);
+        test_verify("opal_net_addr_isipv4public(10.255.255.255) is false (RFC1918)",
+                    !opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 172.16.0.1 -- RFC1918 private (172.16.0.0/12) */
+    {
+        struct sockaddr_in sin = make_sin("172.16.0.1", 0);
+        test_verify("opal_net_addr_isipv4public(172.16.0.1) is false (RFC1918)",
+                    !opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 172.31.255.255 -- still in 172.16.0.0/12 */
+    {
+        struct sockaddr_in sin = make_sin("172.31.255.255", 0);
+        test_verify("opal_net_addr_isipv4public(172.31.255.255) is false (RFC1918)",
+                    !opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 172.32.0.1 -- just outside 172.16.0.0/12 (172.16-31.x.x only) */
+    {
+        struct sockaddr_in sin = make_sin("172.32.0.1", 0);
+        test_verify("opal_net_addr_isipv4public(172.32.0.1) is true (outside RFC1918)",
+                    opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 192.168.0.1 -- RFC1918 private (192.168.0.0/16) */
+    {
+        struct sockaddr_in sin = make_sin("192.168.0.1", 0);
+        test_verify("opal_net_addr_isipv4public(192.168.0.1) is false (RFC1918)",
+                    !opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+    /* 169.254.1.1 -- link-local (169.254.0.0/16) */
+    {
+        struct sockaddr_in sin = make_sin("169.254.1.1", 0);
+        test_verify("opal_net_addr_isipv4public(169.254.1.1) is false (link-local)",
+                    !opal_net_addr_isipv4public((struct sockaddr *) &sin));
+    }
+
+#if OPAL_ENABLE_IPV6
+    /* IPv6 addresses always return false from this function */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("2001:db8::1", 0);
+        test_verify("opal_net_addr_isipv4public(IPv6 addr) is false",
+                    !opal_net_addr_isipv4public((struct sockaddr *) &sin6));
+    }
+#endif /* OPAL_ENABLE_IPV6 */
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_addr_isipv6linklocal                                 */
+/* ------------------------------------------------------------------ */
+
+#if OPAL_ENABLE_IPV6
+static void
+test_addr_isipv6linklocal(void)
+{
+    /* fe80::1 is a link-local address */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("fe80::1", 0);
+        test_verify("opal_net_addr_isipv6linklocal(fe80::1) is true",
+                    opal_net_addr_isipv6linklocal((struct sockaddr *) &sin6));
+    }
+
+    /* fe80::ffff is still link-local */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("fe80::ffff", 0);
+        test_verify("opal_net_addr_isipv6linklocal(fe80::ffff) is true",
+                    opal_net_addr_isipv6linklocal((struct sockaddr *) &sin6));
+    }
+
+    /* ::1 is loopback, not link-local */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("::1", 0);
+        test_verify("opal_net_addr_isipv6linklocal(::1) is false",
+                    !opal_net_addr_isipv6linklocal((struct sockaddr *) &sin6));
+    }
+
+    /* 2001:db8::1 is a global unicast address, not link-local */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("2001:db8::1", 0);
+        test_verify("opal_net_addr_isipv6linklocal(2001:db8::1) is false",
+                    !opal_net_addr_isipv6linklocal((struct sockaddr *) &sin6));
+    }
+
+    /* IPv4 address -> always false */
+    {
+        struct sockaddr_in sin = make_sin("127.0.0.1", 0);
+        test_verify("opal_net_addr_isipv6linklocal(IPv4 addr) is false",
+                    !opal_net_addr_isipv6linklocal((struct sockaddr *) &sin));
+    }
+}
+#endif /* OPAL_ENABLE_IPV6 */
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_get_hostname                                         */
+/*                                                                     */
+/* Returns a per-thread static buffer -- do NOT free the result.      */
+/* ------------------------------------------------------------------ */
+
+static void
+test_get_hostname(void)
+{
+    /* 127.0.0.1 -> should produce the string "127.0.0.1" */
+    {
+        struct sockaddr_in sin = make_sin("127.0.0.1", 0);
+        const char *h = opal_net_get_hostname((struct sockaddr *) &sin);
+        test_verify("opal_net_get_hostname(127.0.0.1) is non-NULL",
+                    NULL != h);
+        if (NULL != h) {
+            test_verify("opal_net_get_hostname(127.0.0.1) == \"127.0.0.1\"",
+                        0 == strcmp("127.0.0.1", h));
+        }
+    }
+
+    /* 8.8.8.8 -> should produce the string "8.8.8.8" */
+    {
+        struct sockaddr_in sin = make_sin("8.8.8.8", 0);
+        const char *h = opal_net_get_hostname((struct sockaddr *) &sin);
+        test_verify("opal_net_get_hostname(8.8.8.8) is non-NULL",
+                    NULL != h);
+        if (NULL != h) {
+            test_verify("opal_net_get_hostname(8.8.8.8) == \"8.8.8.8\"",
+                        0 == strcmp("8.8.8.8", h));
+        }
+    }
+
+#if OPAL_ENABLE_IPV6
+    /* ::1 should produce "::1" (or equivalent minimal form) */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("::1", 0);
+        const char *h = opal_net_get_hostname((struct sockaddr *) &sin6);
+        test_verify("opal_net_get_hostname(::1) is non-NULL",
+                    NULL != h);
+        if (NULL != h) {
+            test_verify("opal_net_get_hostname(::1) is non-empty",
+                        '\0' != h[0]);
+        }
+    }
+
+    /* fe80::1 */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("fe80::1", 0);
+        const char *h = opal_net_get_hostname((struct sockaddr *) &sin6);
+        test_verify("opal_net_get_hostname(fe80::1) is non-NULL",
+                    NULL != h);
+    }
+#endif /* OPAL_ENABLE_IPV6 */
+}
+
+/* ------------------------------------------------------------------ */
+/* Test: opal_net_get_port                                             */
+/* ------------------------------------------------------------------ */
+
+static void
+test_get_port(void)
+{
+    /* IPv4: port 80 */
+    {
+        struct sockaddr_in sin = make_sin("192.168.1.1", 80);
+        test_verify("opal_net_get_port(sin, port=80) == 80",
+                    80 == opal_net_get_port((struct sockaddr *) &sin));
+    }
+
+    /* IPv4: port 0 */
+    {
+        struct sockaddr_in sin = make_sin("0.0.0.0", 0);
+        test_verify("opal_net_get_port(sin, port=0) == 0",
+                    0 == opal_net_get_port((struct sockaddr *) &sin));
+    }
+
+    /* IPv4: port 65535 */
+    {
+        struct sockaddr_in sin = make_sin("127.0.0.1", 65535);
+        test_verify("opal_net_get_port(sin, port=65535) == 65535",
+                    65535 == opal_net_get_port((struct sockaddr *) &sin));
+    }
+
+#if OPAL_ENABLE_IPV6
+    /* IPv6: port 443 */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("::1", 443);
+        test_verify("opal_net_get_port(sin6, port=443) == 443",
+                    443 == opal_net_get_port((struct sockaddr *) &sin6));
+    }
+
+    /* IPv6: port 0 */
+    {
+        struct sockaddr_in6 sin6 = make_sin6("2001:db8::1", 0);
+        test_verify("opal_net_get_port(sin6, port=0) == 0",
+                    0 == opal_net_get_port((struct sockaddr *) &sin6));
+    }
+#endif /* OPAL_ENABLE_IPV6 */
+
+    /* Unknown family -> returns -1 */
+    {
+        struct sockaddr sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_family = AF_UNSPEC;
+        test_verify("opal_net_get_port(AF_UNSPEC) == -1",
+                    -1 == opal_net_get_port(&sa));
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int rc;
+
+    /* test_addr_isipv4public()'s RFC1918 assertions assume the built-in
+       default private-address table.  Clear any inherited
+       OMPI_MCA_opal_net_private_ipv4 so the test exercises those defaults
+       rather than a table injected via the environment. */
+    unsetenv("OMPI_MCA_opal_net_private_ipv4");
+
+    rc = opal_init_util(&argc, &argv);
+    test_init("opal_net");
+    test_verify("opal_init_util() succeeds", OPAL_SUCCESS == rc);
+
+    rc = opal_net_init();
+    test_verify("opal_net_init() succeeds", OPAL_SUCCESS == rc);
+
+    test_isaddr();
+    test_prefix2netmask();
+    test_islocalhost();
+    test_samenetwork();
+    test_addr_isipv4public();
+#if OPAL_ENABLE_IPV6
+    test_addr_isipv6linklocal();
+#endif /* OPAL_ENABLE_IPV6 */
+    test_get_hostname();
+    test_get_port();
+
+    {
+        int r = test_finalize();
+        opal_finalize_util();
+        return r;
+    }
+}
diff --git a/test/util/opal_numtostr.c b/test/util/opal_numtostr.c
new file mode 100644
index 00000000000..9f805d59757
--- /dev/null
+++ b/test/util/opal_numtostr.c
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "support.h"
+#include "opal/util/numtostr.h"
+#include "opal/constants.h"
+
+int main(int argc, char *argv[])
+{
+    char *result;
+
+    test_init("opal_numtostr");
+
+    /* --- opal_ltostr: zero --- */
+    result = opal_ltostr(0L);
+    test_verify("ltostr(0): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("ltostr(0): equals '0'", 0 == strcmp(result, "0"));
+        free(result);
+    }
+
+    /* --- opal_ltostr: positive --- */
+    result = opal_ltostr(42L);
+    test_verify("ltostr(42): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("ltostr(42): equals '42'", 0 == strcmp(result, "42"));
+        free(result);
+    }
+
+    /* --- opal_ltostr: negative --- */
+    result = opal_ltostr(-1L);
+    test_verify("ltostr(-1): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("ltostr(-1): equals '-1'", 0 == strcmp(result, "-1"));
+        free(result);
+    }
+
+    /* --- opal_ltostr: negative large --- */
+    result = opal_ltostr(-9999L);
+    test_verify("ltostr(-9999): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("ltostr(-9999): equals '-9999'", 0 == strcmp(result, "-9999"));
+        free(result);
+    }
+
+    /* --- opal_ltostr: large positive --- */
+    result = opal_ltostr(1000000L);
+    test_verify("ltostr(1000000): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("ltostr(1000000): equals '1000000'", 0 == strcmp(result, "1000000"));
+        free(result);
+    }
+
+    /* --- opal_ltostr: value 10 (original test case) --- */
+    result = opal_ltostr(10L);
+    test_verify("ltostr(10): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("ltostr(10): equals '10'", 0 == strcmp(result, "10"));
+        free(result);
+    }
+
+    /* --- opal_dtostr: zero ---
+     * %f with no precision specifier always produces 6 decimal digits.
+     */
+    result = opal_dtostr(0.0);
+    test_verify("dtostr(0.0): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("dtostr(0.0): equals '0.000000'", 0 == strcmp(result, "0.000000"));
+        free(result);
+    }
+
+    /* --- opal_dtostr: positive --- */
+    result = opal_dtostr(1.0);
+    test_verify("dtostr(1.0): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("dtostr(1.0): equals '1.000000'", 0 == strcmp(result, "1.000000"));
+        free(result);
+    }
+
+    /* --- opal_dtostr: positive fractional (original test case) --- */
+    result = opal_dtostr(5.32);
+    test_verify("dtostr(5.32): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("dtostr(5.32): equals '5.320000'", 0 == strcmp(result, "5.320000"));
+        free(result);
+    }
+
+    /* --- opal_dtostr: negative --- */
+    result = opal_dtostr(-3.14);
+    test_verify("dtostr(-3.14): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("dtostr(-3.14): equals '-3.140000'", 0 == strcmp(result, "-3.140000"));
+        free(result);
+    }
+
+    /* --- opal_dtostr: large value --- */
+    result = opal_dtostr(1e6);
+    test_verify("dtostr(1e6): not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("dtostr(1e6): equals '1000000.000000'",
+                    0 == strcmp(result, "1000000.000000"));
+        free(result);
+    }
+
+    return test_finalize();
+}
diff --git a/test/util/opal_os_dirpath.c b/test/util/opal_os_dirpath.c
new file mode 100644
index 00000000000..a378622c6eb
--- /dev/null
+++ b/test/util/opal_os_dirpath.c
@@ -0,0 +1,417 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal/util/os_dirpath.c
+ *
+ * Covers: opal_os_dirpath_create, opal_os_dirpath_is_empty,
+ *         opal_os_dirpath_access, opal_os_dirpath_destroy.
+ *
+ * All temp directories are created under a mkdtemp base and cleaned
+ * up before the process exits.  We use S_IRWXU throughout to avoid
+ * umask stripping group/other bits and making mode assertions flaky.
+ *
+ * Library is compiled with -DNDEBUG, so assert() is a no-op.
+ * All verification must go through test_verify().
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/os_dirpath.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+/* ------------------------------------------------------------------ */
+/* Helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Create a regular file at the given path.  Returns 0 on success.
+ */
+static int create_file(const char *path)
+{
+    int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
+    if (-1 == fd) {
+        return -1;
+    }
+    close(fd);
+    return 0;
+}
+
+/*
+ * Build a path string from two components without using opal_os_path().
+ * Result is malloc'd; caller must free().
+ */
+static char *path_join(const char *base, const char *sub)
+{
+    size_t len = strlen(base) + 1 + strlen(sub) + 1;
+    char *p = malloc(len);
+    if (NULL != p) {
+        snprintf(p, len, "%s/%s", base, sub);
+    }
+    return p;
+}
+
+/*
+ * Build a path string from three components.  Result is malloc'd.
+ */
+static char *path_join3(const char *a, const char *b, const char *c)
+{
+    size_t len = strlen(a) + 1 + strlen(b) + 1 + strlen(c) + 1;
+    char *p = malloc(len);
+    if (NULL != p) {
+        snprintf(p, len, "%s/%s/%s", a, b, c);
+    }
+    return p;
+}
+
+/* ------------------------------------------------------------------ */
+/* Forward declarations                                                */
+/* ------------------------------------------------------------------ */
+
+static void test_create_null_path(void);
+static void test_create_existing_dir(void);
+static void test_create_nested_dirs(void);
+static void test_is_empty(void);
+static void test_access_nonexistent(void);
+static void test_access_exists_match(void);
+static void test_access_exists_no_match(void);
+static void test_destroy_recursive_no_callback(void);
+static void test_destroy_recursive_with_callback(void);
+static void test_destroy_nonexistent(void);
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    test_init("opal_os_dirpath");
+
+    opal_init_util(&argc, &argv);
+
+    test_create_null_path();
+    test_create_existing_dir();
+    test_create_nested_dirs();
+    test_is_empty();
+    test_access_nonexistent();
+    test_access_exists_match();
+    test_access_exists_no_match();
+    test_destroy_recursive_no_callback();
+    test_destroy_recursive_with_callback();
+    test_destroy_nonexistent();
+
+    int r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_create_null_path(void)
+{
+    int rc = opal_os_dirpath_create(NULL, S_IRWXU);
+    test_verify("create(NULL) returns error", OPAL_SUCCESS != rc);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_create_existing_dir(void)
+{
+    /* Create a temp dir with mkdtemp, then call opal_os_dirpath_create
+     * on it.  It already exists with the right permissions, so the
+     * function should succeed immediately. */
+    char tmpl[] = "/tmp/opal_test_XXXXXX";
+    char *base = mkdtemp(tmpl);
+    if (NULL == base) {
+        test_failure("test_create_existing_dir: mkdtemp failed");
+        return;
+    }
+
+    int rc = opal_os_dirpath_create(base, S_IRWXU);
+    test_verify("create on existing dir returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    rmdir(base);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * Force the "build our way down the tree" branch by requesting a
+ * two-level path that does not yet exist under the temp root.
+ */
+static void test_create_nested_dirs(void)
+{
+    char tmpl[] = "/tmp/opal_test_XXXXXX";
+    char *base = mkdtemp(tmpl);
+    if (NULL == base) {
+        test_failure("test_create_nested_dirs: mkdtemp failed");
+        return;
+    }
+
+    char *leaf = path_join3(base, "level1", "level2");
+    if (NULL == leaf) {
+        test_failure("test_create_nested_dirs: OOM building path");
+        rmdir(base);
+        return;
+    }
+
+    int rc = opal_os_dirpath_create(leaf, S_IRWXU);
+    test_verify("create nested dirs returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* The leaf must exist and be a directory */
+    struct stat buf;
+    int sr = stat(leaf, &buf);
+    test_verify("nested leaf directory exists after create", 0 == sr);
+    test_verify("nested leaf is a directory", 0 == sr && S_ISDIR(buf.st_mode));
+
+    /* The required mode bits must be set */
+    test_verify("nested leaf has S_IRWXU permission bits",
+                0 == sr && (S_IRWXU == (buf.st_mode & S_IRWXU)));
+
+    /* Clean up */
+    rmdir(leaf);
+    char *mid = path_join(base, "level1");
+    if (NULL != mid) {
+        rmdir(mid);
+        free(mid);
+    }
+    rmdir(base);
+    free(leaf);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_is_empty(void)
+{
+    char tmpl[] = "/tmp/opal_test_XXXXXX";
+    char *base = mkdtemp(tmpl);
+    if (NULL == base) {
+        test_failure("test_is_empty: mkdtemp failed");
+        return;
+    }
+
+    /* Fresh directory must be empty */
+    test_verify("fresh dir is empty", true == opal_os_dirpath_is_empty(base));
+
+    /* Create a file inside */
+    char *fpath = path_join(base, "afile");
+    if (NULL == fpath) {
+        test_failure("test_is_empty: OOM");
+        rmdir(base);
+        return;
+    }
+
+    int cr = create_file(fpath);
+    if (0 != cr) {
+        test_failure("test_is_empty: could not create file");
+        free(fpath);
+        rmdir(base);
+        return;
+    }
+
+    test_verify("dir with file is not empty",
+                false == opal_os_dirpath_is_empty(base));
+
+    unlink(fpath);
+    free(fpath);
+
+    test_verify("dir is empty again after file removed",
+                true == opal_os_dirpath_is_empty(base));
+
+    rmdir(base);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_access_nonexistent(void)
+{
+    /* A path that certainly does not exist */
+    int rc = opal_os_dirpath_access("/tmp/opal_nonexistent_dir_xyz987", S_IRWXU);
+    test_verify("access on non-existent path returns OPAL_ERR_NOT_FOUND",
+                OPAL_ERR_NOT_FOUND == rc);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_access_exists_match(void)
+{
+    char tmpl[] = "/tmp/opal_test_XXXXXX";
+    char *base = mkdtemp(tmpl);
+    if (NULL == base) {
+        test_failure("test_access_exists_match: mkdtemp failed");
+        return;
+    }
+    /* mkdtemp creates with 0700 = S_IRWXU; requesting S_IRWXU must succeed */
+    int rc = opal_os_dirpath_access(base, S_IRWXU);
+    test_verify("access on dir with matching mode returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+
+    rmdir(base);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_access_exists_no_match(void)
+{
+    char tmpl[] = "/tmp/opal_test_XXXXXX";
+    char *base = mkdtemp(tmpl);
+    if (NULL == base) {
+        test_failure("test_access_exists_no_match: mkdtemp failed");
+        return;
+    }
+    /* Strip all permissions so S_IRWXU won't match */
+    chmod(base, 0);
+
+    int rc = opal_os_dirpath_access(base, S_IRWXU);
+    test_verify("access on dir with wrong mode returns OPAL_ERROR",
+                OPAL_ERROR == rc);
+
+    /* Restore so rmdir can proceed */
+    chmod(base, S_IRWXU);
+    rmdir(base);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_destroy_recursive_no_callback(void)
+{
+    char tmpl[] = "/tmp/opal_test_XXXXXX";
+    char *base = mkdtemp(tmpl);
+    if (NULL == base) {
+        test_failure("test_destroy_recursive_no_callback: mkdtemp failed");
+        return;
+    }
+
+    /* Populate: base/sub/ and base/sub/file */
+    char *sub = path_join(base, "sub");
+    if (NULL == sub) {
+        test_failure("test_destroy_recursive_no_callback: OOM");
+        rmdir(base);
+        return;
+    }
+    mkdir(sub, S_IRWXU);
+
+    char *fpath = path_join(sub, "file");
+    if (NULL == fpath) {
+        test_failure("test_destroy_recursive_no_callback: OOM fpath");
+        rmdir(sub);
+        rmdir(base);
+        free(sub);
+        return;
+    }
+    create_file(fpath);
+
+    int rc = opal_os_dirpath_destroy(base, true /*recursive*/, NULL /*no cb*/);
+    test_verify("recursive destroy (no cb) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* base itself must be gone (destroy rmdir's it when empty) */
+    struct stat buf;
+    test_verify("top dir removed after recursive destroy", 0 != stat(base, &buf));
+
+    free(fpath);
+    free(sub);
+}
+
+/* ------------------------------------------------------------------ */
+
+/*
+ * Callback that vetoes removal of files named "protected".
+ */
+static bool cb_protect(const char *root, const char *name)
+{
+    (void) root;
+    if (0 == strcmp(name, "protected")) {
+        return false; /* do NOT remove */
+    }
+    return true; /* allow removal */
+}
+
+static void test_destroy_recursive_with_callback(void)
+{
+    char tmpl[] = "/tmp/opal_test_XXXXXX";
+    char *base = mkdtemp(tmpl);
+    if (NULL == base) {
+        test_failure("test_destroy_recursive_with_callback: mkdtemp failed");
+        return;
+    }
+
+    /* Create base/protected and base/removable */
+    char *prot = path_join(base, "protected");
+    char *remo = path_join(base, "removable");
+    if (NULL == prot || NULL == remo) {
+        test_failure("test_destroy_recursive_with_callback: OOM");
+        if (NULL != prot) { free(prot); }
+        if (NULL != remo) { free(remo); }
+        rmdir(base);
+        return;
+    }
+    create_file(prot);
+    create_file(remo);
+
+    /*
+     * destroy with the protecting callback.  The callback returns
+     * false for "protected", so that file stays.  "removable" gets
+     * unlinked.  Because the directory is not empty (protected is
+     * still there), the top dir itself is NOT removed by the
+     * cleanup block.
+     */
+    int rc = opal_os_dirpath_destroy(base, true, cb_protect);
+    test_verify("destroy with protect callback returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    /* "protected" must still exist */
+    struct stat buf;
+    test_verify("protected file survives callback veto", 0 == stat(prot, &buf));
+
+    /* "removable" must be gone */
+    test_verify("removable file was removed", 0 != stat(remo, &buf));
+
+    /* base dir must still exist (not empty) */
+    test_verify("base dir survives (not empty)", 0 == stat(base, &buf));
+
+    /* Manual cleanup */
+    unlink(prot);
+    rmdir(base);
+
+    free(prot);
+    free(remo);
+}
+
+/* ------------------------------------------------------------------ */
+
+static void test_destroy_nonexistent(void)
+{
+    int rc = opal_os_dirpath_destroy("/tmp/opal_nonexistent_dir_xyz987",
+                                    true, NULL);
+    test_verify("destroy on non-existent path returns OPAL_ERR_NOT_FOUND",
+                OPAL_ERR_NOT_FOUND == rc);
+}
diff --git a/test/util/opal_os_path.c b/test/util/opal_os_path.c
index b5556401b60..fe00cb0d60c 100644
--- a/test/util/opal_os_path.c
+++ b/test/util/opal_os_path.c
@@ -9,6 +9,7 @@
  *                         University of Stuttgart.  All rights reserved.
  * Copyright (c) 2004-2005 The Regents of the University of California.
  *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -16,178 +17,142 @@
  * $HEADER$
  */
 
-#include "orte_config.h"
-#include <stdio.h>
+#include "opal_config.h"
+
 #include <stdlib.h>
 #include <string.h>
 #ifdef HAVE_SYS_PARAM_H
 #    include <sys/param.h>
 #endif
 
-#include "opal/runtime/opal.h"
-#include "opal/util/os_path.h"
 #include "support.h"
-
-#define PATH_SEP "/"
-
-static const char *path_sep = PATH_SEP;
-
-static bool test1(void); /* trivial answer test */
-static bool test2(void); /* relative path test */
-static bool test3(void); /* absolute path test */
-static bool test4(void); /* missing path separator test */
+#include "opal/util/os_path.h"
+#include "opal/constants.h"
 
 int main(int argc, char *argv[])
 {
-    opal_init(&argc, &argv);
-
-    test_init("opal_os_path_t");
+    char *result;
+    char long_elem[OPAL_PATH_MAX + 16];
+    int i;
 
-    if (test1()) {
-        test_success();
-    } else {
-        test_failure("opal_os_path_t test1 failed");
-    }
+    test_init("opal_os_path");
 
-    if (test2()) {
-        test_success();
-    } else {
-        test_failure("opal_os_path_t test2 failed");
-    }
+    /* ================================================================
+     * Trivial: no path elements
+     * ================================================================ */
 
-    if (test3()) {
-        test_success();
-    } else {
-        test_failure("opal_os_path_t test3 failed");
+    /* Relative, no elements -> "./" */
+    result = opal_os_path(1 /*relative*/, NULL);
+    test_verify("relative no-args: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("relative no-args: equals './'", 0 == strcmp(result, "./"));
+        free(result);
     }
 
-    if (test4()) {
-        test_success();
-    } else {
-        test_failure("opal_os_path_t test4 failed");
+    /* Absolute, no elements -> "/" */
+    result = opal_os_path(0 /*absolute*/, NULL);
+    test_verify("absolute no-args: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("absolute no-args: equals '/'", 0 == strcmp(result, "/"));
+        free(result);
     }
 
-    opal_finalize();
+    /* ================================================================
+     * Relative paths
+     * ================================================================ */
 
-    test_finalize();
-    return 0;
-}
-
-static bool test1(void)
-{
-    char *out, answer[100];
-
-    /* Test trivial functionality. Program should return ".[separator]" when called in relative
-     * mode, and the separator character when called in absolute mode. */
-    if (NULL != (out = opal_os_path(true, NULL))) {
-        answer[0] = '\0';
-        strcat(answer, ".");
-        strcat(answer, path_sep);
-        if (0 != strcmp(answer, out))
-            return false;
-        free(out);
+    /* Single element */
+    result = opal_os_path(1, "aaa", NULL);
+    test_verify("relative 1-elem: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("relative 1-elem: equals './aaa'", 0 == strcmp(result, "./aaa"));
+        free(result);
     }
-    if (NULL != (out = opal_os_path(false, NULL))) {
-        if (0 != strcmp(path_sep, out))
-            return false;
-        free(out);
+
+    /* Two elements */
+    result = opal_os_path(1, "aaa", "bbb", NULL);
+    test_verify("relative 2-elem: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("relative 2-elem: equals './aaa/bbb'",
+                    0 == strcmp(result, "./aaa/bbb"));
+        free(result);
     }
 
-    return true;
-}
+    /* Three elements */
+    result = opal_os_path(1, "aaa", "bbb", "ccc", NULL);
+    test_verify("relative 3-elem: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("relative 3-elem: equals './aaa/bbb/ccc'",
+                    0 == strcmp(result, "./aaa/bbb/ccc"));
+        free(result);
+    }
 
-static bool test2(void)
-{
-    char out[1024];
-    char *tmp;
-    char *a[] = {"aaa", "bbb", "ccc", NULL};
+    /* ================================================================
+     * Absolute paths
+     * ================================================================ */
 
-    if (NULL == path_sep) {
-        printf("test2 cannot be run\n");
-        return false;
+    /* Single element */
+    result = opal_os_path(0, "aaa", NULL);
+    test_verify("absolute 1-elem: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("absolute 1-elem: equals '/aaa'", 0 == strcmp(result, "/aaa"));
+        free(result);
     }
 
-    /* Construct a relative path name and see if it comes back correctly. Check multiple depths. */
-    out[0] = '\0';
-    strcat(out, ".");
-    strcat(out, path_sep);
-    strcat(out, a[0]);
-
-    tmp = opal_os_path(true, a[0], NULL);
-    if (0 != strcmp(out, tmp))
-        return false;
-    free(tmp);
-
-    strcat(out, path_sep);
-    strcat(out, a[1]);
-    tmp = opal_os_path(true, a[0], a[1], NULL);
-    if (0 != strcmp(out, tmp))
-        return false;
-    free(tmp);
-
-    strcat(out, path_sep);
-    strcat(out, a[2]);
-    tmp = opal_os_path(true, a[0], a[1], a[2], NULL);
-    if (0 != strcmp(out, tmp))
-        return false;
-    free(tmp);
-
-    return true;
-}
-
-static bool test3(void)
-{
-    char out[1024];
-    char *tmp;
-    char *a[] = {"aaa", "bbb", "ccc", NULL};
+    /* Two elements */
+    result = opal_os_path(0, "aaa", "bbb", NULL);
+    test_verify("absolute 2-elem: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("absolute 2-elem: equals '/aaa/bbb'",
+                    0 == strcmp(result, "/aaa/bbb"));
+        free(result);
+    }
 
-    if (NULL == path_sep) {
-        printf("test3 cannot be run\n");
-        return false;
+    /* Three elements */
+    result = opal_os_path(0, "aaa", "bbb", "ccc", NULL);
+    test_verify("absolute 3-elem: not NULL", NULL != result);
+    if (NULL != result) {
+        test_verify("absolute 3-elem: equals '/aaa/bbb/ccc'",
+                    0 == strcmp(result, "/aaa/bbb/ccc"));
+        free(result);
     }
 
-    /* Same as prior test, only with absolute path name */
-    out[0] = '\0';
-    strcat(out, path_sep);
-    strcat(out, a[0]);
-    tmp = opal_os_path(false, a[0], NULL);
-    if (0 != strcmp(out, tmp))
-        return false;
-    free(tmp);
-
-    strcat(out, path_sep);
-    strcat(out, a[1]);
-    tmp = opal_os_path(false, a[0], a[1], NULL);
-    if (0 != strcmp(out, tmp))
-        return false;
-    free(tmp);
-
-    strcat(out, path_sep);
-    strcat(out, a[2]);
-    tmp = opal_os_path(false, a[0], a[1], a[2], NULL);
-    if (0 != strcmp(out, tmp))
-        return false;
-    free(tmp);
-
-    return true;
-}
+    /* ================================================================
+     * Element that already starts with the path separator:
+     * the implementation skips inserting an extra separator.
+     * ================================================================ */
+
+    result = opal_os_path(0, "/absolute_elem", NULL);
+    test_verify("elem starting with '/': not NULL", NULL != result);
+    if (NULL != result) {
+        /* The element already has the separator, so the result should
+         * be "/absolute_elem" (not "//absolute_elem"). */
+        test_verify("elem starting with '/': equals '/absolute_elem'",
+                    0 == strcmp(result, "/absolute_elem"));
+        free(result);
+    }
 
-static bool test4(void)
-{
-    char a[OPAL_PATH_MAX + 10];
-    int i;
+    /* ================================================================
+     * Path length limit: element too long -> NULL
+     * ================================================================ */
 
-    if (NULL == path_sep) {
-        printf("test4 cannot be run\n");
-        return false;
+    for (i = 0; i < OPAL_PATH_MAX + 10; ++i) {
+        long_elem[i] = 'a';
     }
+    long_elem[OPAL_PATH_MAX + 10] = '\0';
 
-    for (i = 0; i < OPAL_PATH_MAX + 5; i++) {
-        a[i] = 'a';
+    result = opal_os_path(0, long_elem, NULL);
+    test_verify("too-long elem: returns NULL", NULL == result);
+    if (NULL != result) {
+        free(result);
     }
-    a[i] = '\0';
-    if (NULL != opal_os_path(false, a, NULL)) {
-        return false;
+
+    /* Same test for relative mode */
+    result = opal_os_path(1, long_elem, NULL);
+    test_verify("too-long elem (relative): returns NULL", NULL == result);
+    if (NULL != result) {
+        free(result);
     }
-    return true;
+
+    return test_finalize();
 }
diff --git a/test/util/opal_output.c b/test/util/opal_output.c
new file mode 100644
index 00000000000..4face6cc018
--- /dev/null
+++ b/test/util/opal_output.c
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for the opal_output subsystem.
+ *
+ * Functions exercised:
+ *   opal_output_init      (called implicitly by opal_init_util)
+ *   opal_output_open      (open a new stream with an opal_output_stream_t)
+ *   opal_output_close     (close a stream)
+ *   opal_output           (formatted output to a stream)
+ *   opal_output_verbose   (macro -- output gated by verbosity level)
+ *   opal_output_set_verbosity / opal_output_get_verbosity
+ *   opal_output_check_verbosity
+ *   opal_output_string    (return output as a malloc'd string)
+ *   opal_output_reopen    (redirect an existing stream)
+ *   opal_output_set_output_file_info (control file naming for file streams)
+ *
+ * File output strategy:
+ *   We call opal_output_set_output_file_info() to set a known, process-
+ *   unique directory (mkdtemp) and a fixed prefix so the filename is
+ *   predictable.  The file is only created lazily on the first write, so
+ *   we call opal_output() before attempting to fopen() it.  After each
+ *   test we close the stream, unlink the file, and restore the old
+ *   output dir/prefix.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/output.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* ------------------------------------------------------------------ */
+/* helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+/* Build a predictable filename: dir + "/" + prefix + suffix. */
+static void build_filename(char *buf, size_t bufsz,
+                           const char *dir, const char *prefix,
+                           const char *suffix)
+{
+    snprintf(buf, bufsz, "%s/%s%s", dir, prefix, suffix);
+}
+
+/*
+ * Read the entire content of a file into a malloc'd buffer.
+ * Returns NULL on failure.  Caller must free().
+ */
+static char *slurp_file(const char *path)
+{
+    FILE *fp;
+    long len;
+    char *buf;
+    size_t nread;
+
+    fp = fopen(path, "r");
+    if (NULL == fp) {
+        return NULL;
+    }
+    if (0 != fseek(fp, 0, SEEK_END)) {
+        fclose(fp);
+        return NULL;
+    }
+    len = ftell(fp);
+    if (len < 0) {
+        fclose(fp);
+        return NULL;
+    }
+    rewind(fp);
+    buf = (char *) malloc((size_t) len + 1);
+    if (NULL == buf) {
+        fclose(fp);
+        return NULL;
+    }
+    nread = fread(buf, 1, (size_t) len, fp);
+    buf[nread] = '\0';
+    fclose(fp);
+    return buf;
+}
+
+/* ------------------------------------------------------------------ */
+/* test_open_close_stderr                                              */
+/*                                                                     */
+/* Open a stream directed only to stderr; verify handle is >= 0;      */
+/* then close it.                                                      */
+/* ------------------------------------------------------------------ */
+static void test_open_close_stderr(void)
+{
+    opal_output_stream_t lds;
+    int h;
+
+    OBJ_CONSTRUCT(&lds, opal_output_stream_t);
+    lds.lds_want_stderr = true;
+
+    h = opal_output_open(&lds);
+    test_verify("opal_output_open(stderr) returns valid handle", h >= 0);
+    if (h >= 0) {
+        opal_output_close(h);
+    }
+    OBJ_DESTRUCT(&lds);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_verbosity_get_set                                              */
+/*                                                                     */
+/* Open a stream, set its verbosity, read it back, and check the      */
+/* gating predicate opal_output_check_verbosity.                      */
+/* ------------------------------------------------------------------ */
+static void test_verbosity_get_set(void)
+{
+    opal_output_stream_t lds;
+    int h;
+
+    OBJ_CONSTRUCT(&lds, opal_output_stream_t);
+    lds.lds_want_stderr  = true;
+    lds.lds_verbose_level = 0;
+
+    h = opal_output_open(&lds);
+    test_verify("verbosity test: open succeeds", h >= 0);
+    if (h < 0) {
+        OBJ_DESTRUCT(&lds);
+        return;
+    }
+
+    /* After open, verbosity should be 0 (set in lds). */
+    test_verify("verbosity: initial get_verbosity == 0",
+                0 == opal_output_get_verbosity(h));
+
+    /* check_verbosity(0, h): level 0 <= stream verbosity 0 -> true */
+    test_verify("verbosity: check_verbosity(0) true when level == 0",
+                opal_output_check_verbosity(0, h));
+
+    /* check_verbosity(1, h): level 1 > stream verbosity 0 -> false */
+    test_verify("verbosity: check_verbosity(1) false when stream_level == 0",
+                !opal_output_check_verbosity(1, h));
+
+    opal_output_set_verbosity(h, 5);
+    test_verify("verbosity: set_verbosity(5) -> get == 5",
+                5 == opal_output_get_verbosity(h));
+
+    /* Now level 5 should pass, level 6 should not. */
+    test_verify("verbosity: check_verbosity(5) true when stream_level == 5",
+                opal_output_check_verbosity(5, h));
+    test_verify("verbosity: check_verbosity(6) false when stream_level == 5",
+                !opal_output_check_verbosity(6, h));
+
+    opal_output_close(h);
+    OBJ_DESTRUCT(&lds);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_output_string                                                  */
+/*                                                                     */
+/* opal_output_string returns a malloc'd string when verbose_level    */
+/* permits, and NULL when it does not.                                 */
+/* ------------------------------------------------------------------ */
+static void test_output_string(void)
+{
+    opal_output_stream_t lds;
+    int h;
+    char *s;
+
+    OBJ_CONSTRUCT(&lds, opal_output_stream_t);
+    lds.lds_want_stderr   = false;
+    lds.lds_verbose_level = 3;
+
+    h = opal_output_open(&lds);
+    test_verify("output_string: open succeeds", h >= 0);
+    if (h < 0) {
+        OBJ_DESTRUCT(&lds);
+        return;
+    }
+
+    /* level 3 <= stream verbosity 3 -> should return a string */
+    s = opal_output_string(3, h, "hello %s", "world");
+    test_verify("output_string: returns non-NULL when level <= verbosity",
+                NULL != s);
+    if (NULL != s) {
+        test_verify("output_string: payload present in returned string",
+                    NULL != strstr(s, "hello world"));
+        free(s);
+    }
+
+    /* level 4 > stream verbosity 3 -> should return NULL */
+    s = opal_output_string(4, h, "should not appear");
+    test_verify("output_string: returns NULL when level > verbosity",
+                NULL == s);
+
+    opal_output_close(h);
+    OBJ_DESTRUCT(&lds);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_output_verbose_macro                                           */
+/*                                                                     */
+/* opal_output_verbose is a macro gated by opal_output_check_verbosity*/
+/* We can only verify it compiles and doesn't crash; side effects are  */
+/* to stderr so we can't capture them here.                            */
+/* ------------------------------------------------------------------ */
+static void test_output_verbose_macro(void)
+{
+    opal_output_stream_t lds;
+    int h;
+
+    OBJ_CONSTRUCT(&lds, opal_output_stream_t);
+    lds.lds_want_stderr   = true;
+    lds.lds_verbose_level = 2;
+
+    h = opal_output_open(&lds);
+    test_verify("output_verbose: open succeeds", h >= 0);
+    if (h < 0) {
+        OBJ_DESTRUCT(&lds);
+        return;
+    }
+
+    /* These calls must not crash (level 2 passes; level 3 is suppressed). */
+    opal_output_verbose(2, h, "verbose message at level 2");
+    opal_output_verbose(3, h, "this should be suppressed");
+
+    test_verify("output_verbose: survived both calls without crash", 1);
+
+    opal_output_close(h);
+    OBJ_DESTRUCT(&lds);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_file_output                                                    */
+/*                                                                     */
+/* Direct output to a file in a temp directory, then verify the file  */
+/* received the payload.                                               */
+/*                                                                     */
+/* File naming: output_dir + "/" + output_prefix + suffix             */
+/*   We set output_dir = our tmpdir                                   */
+/*      and output_prefix = "opaltest-"                               */
+/*      suffix = "output-test.txt"                                    */
+/* ------------------------------------------------------------------ */
+static void test_file_output(void)
+{
+    char tmpdir[] = "/tmp/opaltest.XXXXXX";
+    char *dir;
+    char *olddir  = NULL;
+    char *oldpfx  = NULL;
+    opal_output_stream_t lds;
+    int h;
+    char filename[1024];
+    char *content;
+    const char *prefix = "opaltest-";
+    const char *suffix = "output-test.txt";
+    const char *payload = "TESTPAYLOAD_12345";
+
+    dir = mkdtemp(tmpdir);
+    test_verify("test_file_output: mkdtemp succeeded", NULL != dir);
+    if (NULL == dir) {
+        return;
+    }
+
+    /* Redirect output infrastructure to our temp directory. */
+    opal_output_set_output_file_info(dir, prefix, &olddir, &oldpfx);
+
+    OBJ_CONSTRUCT(&lds, opal_output_stream_t);
+    lds.lds_want_stderr      = false;
+    lds.lds_want_file        = true;
+    lds.lds_want_file_append = false;
+    lds.lds_file_suffix      = strdup(suffix); /* owned + freed by OBJ_DESTRUCT */
+
+    h = opal_output_open(&lds);
+    test_verify("test_file_output: open returns valid handle", h >= 0);
+    if (h < 0) {
+        OBJ_DESTRUCT(&lds);
+        opal_output_set_output_file_info(olddir, oldpfx, NULL, NULL);
+        free(olddir);
+        free(oldpfx);
+        rmdir(dir);
+        return;
+    }
+
+    /* The file is created lazily on first write. */
+    opal_output(h, "%s", payload);
+
+    opal_output_close(h);
+    OBJ_DESTRUCT(&lds);
+
+    /* Check content. */
+    build_filename(filename, sizeof(filename), dir, prefix, suffix);
+    content = slurp_file(filename);
+    test_verify("test_file_output: output file exists and is readable",
+                NULL != content);
+    if (NULL != content) {
+        test_verify("test_file_output: payload found in file content",
+                    NULL != strstr(content, payload));
+        free(content);
+    }
+
+    /* Cleanup. */
+    unlink(filename);
+    rmdir(dir);
+
+    /* Restore previous output dir/prefix. */
+    opal_output_set_output_file_info(olddir, oldpfx, NULL, NULL);
+    free(olddir);
+    free(oldpfx);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_reopen                                                         */
+/*                                                                     */
+/* opal_output_reopen() redirects an existing stream to a new set of  */
+/* destinations.  We open a stream to stderr, reopen it with a        */
+/* different verbosity level, and verify the new level took effect.   */
+/* ------------------------------------------------------------------ */
+static void test_reopen(void)
+{
+    opal_output_stream_t lds;
+    int h;
+    int h2;
+
+    OBJ_CONSTRUCT(&lds, opal_output_stream_t);
+    lds.lds_want_stderr   = true;
+    lds.lds_verbose_level = 0;
+
+    h = opal_output_open(&lds);
+    test_verify("reopen: initial open succeeds", h >= 0);
+    if (h < 0) {
+        OBJ_DESTRUCT(&lds);
+        return;
+    }
+
+    /* Reopen with a new verbosity level. */
+    lds.lds_verbose_level = 7;
+    h2 = opal_output_reopen(h, &lds);
+
+    /*
+     * opal_output_reopen returns the stream id (same as h when reopening an
+     * existing id).
+     */
+    test_verify("reopen: returns the same stream id", h == h2);
+    test_verify("reopen: new verbosity level is visible",
+                7 == opal_output_get_verbosity(h));
+
+    opal_output_close(h);
+    OBJ_DESTRUCT(&lds);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_get_verbosity_invalid_handle                                   */
+/*                                                                     */
+/* opal_output_get_verbosity with an unused/invalid id must return -1.*/
+/* ------------------------------------------------------------------ */
+static void test_get_verbosity_invalid_handle(void)
+{
+    /* Stream id 63 is within OPAL_OUTPUT_MAX_STREAMS (64) but we never
+     * open it, so ldi_used should be false and get_verbosity must return -1. */
+    test_verify("get_verbosity(unused id) returns -1",
+                -1 == opal_output_get_verbosity(63));
+
+    /* Negative id: also returns -1. */
+    test_verify("get_verbosity(-1) returns -1",
+                -1 == opal_output_get_verbosity(-1));
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    test_init("opal_output");
+
+    opal_init_util(&argc, &argv);
+
+    test_open_close_stderr();
+    test_verbosity_get_set();
+    test_output_string();
+    test_output_verbose_macro();
+    test_file_output();
+    test_reopen();
+    test_get_verbosity_invalid_handle();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_path.c b/test/util/opal_path.c
new file mode 100644
index 00000000000..ade763b1180
--- /dev/null
+++ b/test/util/opal_path.c
@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2014 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal/util/path.c.
+ *
+ * Note: the library is compiled with -DNDEBUG, so assert() is a no-op.
+ * All verification must go through test_verify().
+ *
+ * opal_path_nfs is covered elsewhere (test/util/opal_path_nfs.c) and
+ * is intentionally omitted here.
+ *
+ * opal_path_access, opal_path_find, and opal_path_findv take char*
+ * (non-const) for fname/path arguments.  To avoid -Wwrite-strings
+ * warnings, all file-name arguments are passed as mutable char arrays.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/path.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* ------------------------------------------------------------------ */
+/* helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Create a temporary regular file (mode 0600) and return its path via
+ * buf (which must be at least 64 bytes).  Returns 0 on success.
+ */
+static int make_temp_file(char *buf, size_t bufsz)
+{
+    int fd;
+
+    snprintf(buf, bufsz, "/tmp/opal_path_test_XXXXXX");
+    fd = mkstemp(buf);
+    if (-1 == fd) {
+        return -1;
+    }
+    close(fd);
+    return 0;
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_path_is_absolute                                               */
+/* ------------------------------------------------------------------ */
+
+static void test_is_absolute(void)
+{
+    /* An absolute path starts with '/' on UNIX. */
+    test_verify("is_absolute('/x') == true",
+                true == opal_path_is_absolute("/x"));
+
+    test_verify("is_absolute('/') == true",
+                true == opal_path_is_absolute("/"));
+
+    test_verify("is_absolute('/usr/bin/sh') == true",
+                true == opal_path_is_absolute("/usr/bin/sh"));
+
+    /* A relative path must return false. */
+    test_verify("is_absolute('x') == false",
+                false == opal_path_is_absolute("x"));
+
+    test_verify("is_absolute('foo/bar') == false",
+                false == opal_path_is_absolute("foo/bar"));
+
+    test_verify("is_absolute('./foo') == false",
+                false == opal_path_is_absolute("./foo"));
+
+    /* An empty string has no leading '/'. */
+    test_verify("is_absolute('') == false",
+                false == opal_path_is_absolute(""));
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_path_access                                                    */
+/* ------------------------------------------------------------------ */
+
+static void test_path_access(void)
+{
+    char tmppath[64];
+    char *result;
+
+    /* Create a regular temporary file (mode 0600 -- user r/w, no x). */
+    if (0 != make_temp_file(tmppath, sizeof(tmppath))) {
+        test_failure("opal_path_access: could not create temp file");
+        return;
+    }
+
+    /* Access an existing regular file with R_OK -- should succeed. */
+    {
+        char fname[64];
+        snprintf(fname, sizeof(fname), "%s", tmppath);
+        result = opal_path_access(fname, NULL, R_OK);
+        test_verify("access existing file R_OK: non-NULL", NULL != result);
+        if (NULL != result) {
+            free(result);
+        }
+    }
+
+    /* Access with mode 0 (existence check) -- should also succeed. */
+    {
+        char fname[64];
+        snprintf(fname, sizeof(fname), "%s", tmppath);
+        result = opal_path_access(fname, NULL, 0);
+        test_verify("access existing file mode=0: non-NULL", NULL != result);
+        if (NULL != result) {
+            free(result);
+        }
+    }
+
+    /* A non-existent path should return NULL. */
+    {
+        char fname[] = "/tmp/opal_path_test_does_not_exist_xyzzy_42";
+        result = opal_path_access(fname, NULL, R_OK);
+        test_verify("access nonexistent file: NULL", NULL == result);
+    }
+
+    /* The temp file has no execute permission (mode 0600), so X_OK
+     * should return NULL.  The stat-based check in opal_path_access
+     * looks at S_IXUSR, not the access(2) syscall, so it behaves
+     * consistently regardless of effective UID. */
+    {
+        char fname[64];
+        snprintf(fname, sizeof(fname), "%s", tmppath);
+        result = opal_path_access(fname, NULL, X_OK);
+        test_verify("access file without X_OK bit: NULL", NULL == result);
+    }
+
+    /* opal_path_access on a directory should return NULL (not a
+     * regular file or symlink). */
+    {
+        char fname[] = "/tmp";
+        result = opal_path_access(fname, NULL, R_OK);
+        test_verify("access directory: NULL", NULL == result);
+    }
+
+    unlink(tmppath);
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_path_find                                                      */
+/* ------------------------------------------------------------------ */
+
+static void test_path_find(void)
+{
+    char *result;
+
+    /* Build a pathv containing common binary directories.  We look for
+     * "sh" which is universally available.  envv is NULL so environment
+     * substitution is skipped. */
+    {
+        char fname[] = "sh";
+        char *pathv[] = {"/bin", "/usr/bin", "/usr/local/bin", NULL};
+        result = opal_path_find(fname, pathv, X_OK, NULL);
+        test_verify("find 'sh' in /bin:/usr/bin: non-NULL", NULL != result);
+        if (NULL != result) {
+            /* Result must be an absolute path. */
+            test_verify("find 'sh': result is absolute",
+                        true == opal_path_is_absolute(result));
+            free(result);
+        }
+    }
+
+    /* Searching for a file that definitely does not exist must return
+     * NULL. */
+    {
+        char fname[] = "opal_test_binary_that_does_not_exist_xyzzy";
+        char *pathv[] = {"/bin", "/usr/bin", NULL};
+        result = opal_path_find(fname, pathv, X_OK, NULL);
+        test_verify("find nonexistent binary: NULL", NULL == result);
+    }
+
+    /* Single-element pathv with a known directory and file. */
+    {
+        char tmppath[64];
+        if (0 == make_temp_file(tmppath, sizeof(tmppath))) {
+            /* Extract directory and basename from tmppath. */
+            char dir[64];
+            char base[64];
+            char *slash;
+
+            snprintf(dir, sizeof(dir), "%s", tmppath);
+            slash = strrchr(dir, '/');
+            if (NULL != slash) {
+                *slash = '\0';
+                snprintf(base, sizeof(base), "%s", slash + 1);
+
+                char *pathv_single[] = {dir, NULL};
+                result = opal_path_find(base, pathv_single, R_OK, NULL);
+                test_verify("find temp file in its dir: non-NULL",
+                            NULL != result);
+                if (NULL != result) {
+                    free(result);
+                }
+            }
+            unlink(tmppath);
+        }
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_path_findv                                                     */
+/* ------------------------------------------------------------------ */
+
+static void test_path_findv(void)
+{
+    char *result;
+
+    /* Build an envv that contains PATH=/bin:/usr/bin.  opal_path_findv
+     * extracts PATH from envv.  We search for "sh" with X_OK. */
+    {
+        char fname[] = "sh";
+        char pathenv[] = "PATH=/bin:/usr/bin:/usr/local/bin";
+        char *envv[] = {pathenv, NULL};
+        result = opal_path_findv(fname, X_OK, envv, NULL);
+        test_verify("findv 'sh' via PATH envv: non-NULL", NULL != result);
+        if (NULL != result) {
+            test_verify("findv 'sh': result is absolute",
+                        true == opal_path_is_absolute(result));
+            free(result);
+        }
+    }
+
+    /* Non-existent binary must return NULL. */
+    {
+        char fname[] = "opal_test_binary_that_does_not_exist_xyzzy";
+        char pathenv[] = "PATH=/bin:/usr/bin";
+        char *envv[] = {pathenv, NULL};
+        result = opal_path_findv(fname, X_OK, envv, NULL);
+        test_verify("findv nonexistent binary: NULL", NULL == result);
+    }
+
+    /* envv=NULL and no system PATH: no binaries should be found in
+     * an environment where PATH truly contains nothing.  We pass a
+     * custom envv with an empty PATH to force a NULL result. */
+    {
+        char fname[] = "sh";
+        char pathenv[] = "PATH=";
+        char *envv[] = {pathenv, NULL};
+        result = opal_path_findv(fname, X_OK, envv, NULL);
+        /* With an empty PATH, "sh" cannot be found. */
+        test_verify("findv 'sh' with empty PATH: NULL", NULL == result);
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_find_absolute_path                                             */
+/* ------------------------------------------------------------------ */
+
+static void test_find_absolute_path(void)
+{
+    char *result;
+
+    /* An already-absolute path to a real binary should return the
+     * canonical path (via realpath).  The result must be non-NULL and
+     * absolute. */
+    {
+        char input[] = "/bin/sh";
+        result = opal_find_absolute_path(input);
+        test_verify("find_absolute_path('/bin/sh'): non-NULL",
+                    NULL != result);
+        if (NULL != result) {
+            test_verify("find_absolute_path('/bin/sh'): result is absolute",
+                        true == opal_path_is_absolute(result));
+            free(result);
+        }
+    }
+
+    /* A path that does not exist should return NULL. */
+    {
+        char input[] = "/bin/opal_test_binary_does_not_exist_xyzzy";
+        result = opal_find_absolute_path(input);
+        test_verify("find_absolute_path nonexistent: NULL", NULL == result);
+    }
+
+    /* A relative name that is present in $PATH (using the real environment)
+     * should be found.  We ask for "sh" which is always in PATH. */
+    {
+        char input[] = "sh";
+        result = opal_find_absolute_path(input);
+        test_verify("find_absolute_path('sh') via PATH: non-NULL",
+                    NULL != result);
+        if (NULL != result) {
+            test_verify("find_absolute_path('sh'): result is absolute",
+                        true == opal_path_is_absolute(result));
+            free(result);
+        }
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* opal_path_df                                                        */
+/* ------------------------------------------------------------------ */
+
+static void test_path_df(void)
+{
+    uint64_t avail;
+    int rc;
+
+    /* Querying '/' must succeed. */
+    avail = 0;
+    rc = opal_path_df("/", &avail);
+    test_verify("path_df('/') returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    /* avail can legitimately be 0 on full filesystems; we just verify
+     * the call succeeded without requiring a particular value. */
+
+    /* NULL path must return OPAL_ERROR. */
+    avail = 0;
+    rc = opal_path_df(NULL, &avail);
+    test_verify("path_df(NULL, &avail) returns OPAL_ERROR",
+                OPAL_ERROR == rc);
+
+    /* NULL out_avail must return OPAL_ERROR. */
+    rc = opal_path_df("/", NULL);
+    test_verify("path_df('/', NULL) returns OPAL_ERROR",
+                OPAL_ERROR == rc);
+
+    /* Query /tmp -- must succeed on any POSIX system. */
+    avail = 0;
+    rc = opal_path_df("/tmp", &avail);
+    test_verify("path_df('/tmp') returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+
+    /* A path that does not exist should return OPAL_ERROR. */
+    avail = 0;
+    rc = opal_path_df("/opal_path_test_nonexistent_dir_xyzzy", &avail);
+    test_verify("path_df(nonexistent) returns OPAL_ERROR",
+                OPAL_ERROR == rc);
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    opal_init_util(&argc, &argv);
+    test_init("opal_path");
+
+    test_is_absolute();
+    test_path_access();
+    test_path_find();
+    test_path_findv();
+    test_find_absolute_path();
+    test_path_df();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_printf.c b/test/util/opal_printf.c
new file mode 100644
index 00000000000..df5e5687d32
--- /dev/null
+++ b/test/util/opal_printf.c
@@ -0,0 +1,341 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+#include "opal/util/printf.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* -----------------------------------------------------------------------
+ * Helpers to exercise the va_list variants
+ * ----------------------------------------------------------------------- */
+
+static int call_vasprintf(char **ptr, const char *fmt, ...)
+{
+    va_list ap;
+    int rc;
+
+    va_start(ap, fmt);
+    rc = opal_vasprintf(ptr, fmt, ap);
+    va_end(ap);
+    return rc;
+}
+
+static int call_vsnprintf(char *str, size_t size, const char *fmt, ...)
+{
+    va_list ap;
+    int rc;
+
+    va_start(ap, fmt);
+    rc = opal_vsnprintf(str, size, fmt, ap);
+    va_end(ap);
+    return rc;
+}
+
+/* -----------------------------------------------------------------------
+ * opal_asprintf tests
+ * ----------------------------------------------------------------------- */
+
+static void test_asprintf_string(void)
+{
+    char *s = NULL;
+    int rc;
+
+    rc = opal_asprintf(&s, "%s", "hello");
+    test_verify("asprintf %s: rc == 5", 5 == rc);
+    test_verify("asprintf %s: string matches", NULL != s && 0 == strcmp("hello", s));
+    free(s);
+}
+
+static void test_asprintf_int(void)
+{
+    char *s = NULL;
+    int rc;
+
+    rc = opal_asprintf(&s, "%d", 42);
+    test_verify("asprintf %d: rc == 2", 2 == rc);
+    test_verify("asprintf %d: string matches", NULL != s && 0 == strcmp("42", s));
+    free(s);
+}
+
+static void test_asprintf_negative_int(void)
+{
+    char *s = NULL;
+    int rc;
+
+    rc = opal_asprintf(&s, "%d", -7);
+    test_verify("asprintf negative int: rc == 2", 2 == rc);
+    test_verify("asprintf negative int: string matches", NULL != s && 0 == strcmp("-7", s));
+    free(s);
+}
+
+static void test_asprintf_float(void)
+{
+    char *s = NULL;
+    int rc;
+
+    /* Use %.1f for predictable output */
+    rc = opal_asprintf(&s, "%.1f", 3.5);
+    test_verify("asprintf %.1f: rc > 0", rc > 0);
+    test_verify("asprintf %.1f: string matches", NULL != s && 0 == strcmp("3.5", s));
+    free(s);
+}
+
+static void test_asprintf_empty_format(void)
+{
+    char *s = NULL;
+    int rc;
+    /* Use a variable to avoid -Wformat-zero-length on a string literal "" */
+    const char *fmt = "";
+
+    rc = opal_asprintf(&s, fmt);
+    test_verify("asprintf empty format: rc == 0", 0 == rc);
+    test_verify("asprintf empty format: string is empty", NULL != s && 0 == strcmp("", s));
+    free(s);
+}
+
+static void test_asprintf_mixed(void)
+{
+    char *s = NULL;
+    int rc;
+
+    rc = opal_asprintf(&s, "%s=%d", "x", 1);
+    test_verify("asprintf mixed: rc == 3", 3 == rc);
+    test_verify("asprintf mixed: string matches", NULL != s && 0 == strcmp("x=1", s));
+    free(s);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_vasprintf tests
+ * ----------------------------------------------------------------------- */
+
+static void test_vasprintf_string(void)
+{
+    char *s = NULL;
+    int rc;
+
+    rc = call_vasprintf(&s, "%s", "world");
+    test_verify("vasprintf %s: rc == 5", 5 == rc);
+    test_verify("vasprintf %s: string matches", NULL != s && 0 == strcmp("world", s));
+    free(s);
+}
+
+static void test_vasprintf_int(void)
+{
+    char *s = NULL;
+    int rc;
+
+    rc = call_vasprintf(&s, "%d", 100);
+    test_verify("vasprintf %d: rc == 3", 3 == rc);
+    test_verify("vasprintf %d: string matches", NULL != s && 0 == strcmp("100", s));
+    free(s);
+}
+
+static void test_vasprintf_empty_format(void)
+{
+    char *s = NULL;
+    int rc;
+    const char *fmt = "";
+
+    rc = call_vasprintf(&s, fmt);
+    test_verify("vasprintf empty format: rc == 0", 0 == rc);
+    test_verify("vasprintf empty format: empty string", NULL != s && 0 == strcmp("", s));
+    free(s);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_snprintf tests
+ * ----------------------------------------------------------------------- */
+
+static void test_snprintf_fits(void)
+{
+    char buf[64];
+    int rc;
+
+    rc = opal_snprintf(buf, sizeof(buf), "%s=%d", "key", 99);
+    test_verify("snprintf fits: rc == 6", 6 == rc);
+    test_verify("snprintf fits: content", 0 == strcmp("key=99", buf));
+}
+
+static void test_snprintf_exact_fit(void)
+{
+    /* "hello" is 5 chars; buffer of 6 is exactly big enough (5 + NUL) */
+    char buf[6];
+    int rc;
+
+    rc = opal_snprintf(buf, sizeof(buf), "%s", "hello");
+    /* Returns full would-have-been length = 5 */
+    test_verify("snprintf exact fit: rc == 5", 5 == rc);
+    test_verify("snprintf exact fit: content", 0 == strcmp("hello", buf));
+}
+
+static void test_snprintf_truncation(void)
+{
+    /* Buffer of 5 forces truncation of "hello" (needs 6 bytes) */
+    char buf[5];
+    int rc;
+
+    rc = opal_snprintf(buf, sizeof(buf), "%s", "hello");
+    /* Returns the would-have-been length (5), not the truncated length */
+    test_verify("snprintf truncation: rc == 5 (would-have-been)", 5 == rc);
+    /* Output must be NUL-terminated */
+    test_verify("snprintf truncation: NUL-terminated", '\0' == buf[4]);
+    /* Truncated content: "hell\0" */
+    test_verify("snprintf truncation: first 4 chars", 0 == strncmp("hell", buf, 4));
+    test_verify("snprintf truncation: strlen == 4", 4 == (int) strlen(buf));
+}
+
+static void test_snprintf_null_buffer_zero_size(void)
+{
+    int rc;
+
+    /* C99: NULL/0 returns the would-have-been length without writing */
+    rc = opal_snprintf(NULL, 0, "%s %d", "test", 1004);
+    test_verify("snprintf NULL/0: returns full length", rc > 0);
+    /* "test 1004" is 9 chars */
+    test_verify("snprintf NULL/0: rc == 9", 9 == rc);
+}
+
+static void test_snprintf_empty_format(void)
+{
+    char buf[8];
+    int rc;
+    const char *fmt = "";
+
+    rc = opal_snprintf(buf, sizeof(buf), fmt);
+    test_verify("snprintf empty format: rc == 0", 0 == rc);
+    test_verify("snprintf empty format: empty string", 0 == strcmp("", buf));
+}
+
+static void test_snprintf_one_byte_buffer(void)
+{
+    /* A 1-byte buffer can only hold the NUL terminator */
+    char buf[1];
+    int rc;
+
+    rc = opal_snprintf(buf, sizeof(buf), "%d", 42);
+    test_verify("snprintf 1-byte buf: returns full length 2", 2 == rc);
+    test_verify("snprintf 1-byte buf: buf[0] is NUL", '\0' == buf[0]);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_vsnprintf tests
+ * ----------------------------------------------------------------------- */
+
+static void test_vsnprintf_fits(void)
+{
+    char buf[64];
+    int rc;
+
+    rc = call_vsnprintf(buf, sizeof(buf), "%s", "vsnprintf");
+    test_verify("vsnprintf fits: rc == 9", 9 == rc);
+    test_verify("vsnprintf fits: content", 0 == strcmp("vsnprintf", buf));
+}
+
+static void test_vsnprintf_truncation(void)
+{
+    char buf[4];
+    int rc;
+
+    /* "abc" fits in 4 bytes ("abc\0"), "abcd" does not */
+    rc = call_vsnprintf(buf, sizeof(buf), "%s", "abcd");
+    /* Returns the full would-have-been length = 4 */
+    test_verify("vsnprintf truncation: rc == 4", 4 == rc);
+    test_verify("vsnprintf truncation: NUL-terminated", '\0' == buf[3]);
+    test_verify("vsnprintf truncation: first 3 chars", 0 == strncmp("abc", buf, 3));
+}
+
+static void test_vsnprintf_length_equals_size_minus_one(void)
+{
+    /* content "abc" is 3 chars; buffer size=4 => fits exactly */
+    char buf[4];
+    int rc;
+
+    rc = call_vsnprintf(buf, sizeof(buf), "%s", "abc");
+    test_verify("vsnprintf length==size-1: rc == 3", 3 == rc);
+    test_verify("vsnprintf length==size-1: content", 0 == strcmp("abc", buf));
+}
+
+static void test_vsnprintf_length_equals_size(void)
+{
+    /* "abcd" is 4 chars; buffer size=4 means last char is dropped */
+    char buf[4];
+    int rc;
+
+    rc = call_vsnprintf(buf, sizeof(buf), "%s", "abcd");
+    test_verify("vsnprintf length==size: rc == 4", 4 == rc);
+    /* Only "abc" fits plus NUL */
+    test_verify("vsnprintf length==size: content truncated", 0 == strcmp("abc", buf));
+}
+
+static void test_vsnprintf_null_zero(void)
+{
+    int rc;
+
+    rc = call_vsnprintf(NULL, 0, "%d", 999);
+    test_verify("vsnprintf NULL/0: returns 3", 3 == rc);
+}
+
+/* -----------------------------------------------------------------------
+ * main
+ * ----------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_printf");
+
+    /* opal_asprintf */
+    test_asprintf_string();
+    test_asprintf_int();
+    test_asprintf_negative_int();
+    test_asprintf_float();
+    test_asprintf_empty_format();
+    test_asprintf_mixed();
+
+    /* opal_vasprintf */
+    test_vasprintf_string();
+    test_vasprintf_int();
+    test_vasprintf_empty_format();
+
+    /* opal_snprintf */
+    test_snprintf_fits();
+    test_snprintf_exact_fit();
+    test_snprintf_truncation();
+    test_snprintf_null_buffer_zero_size();
+    test_snprintf_empty_format();
+    test_snprintf_one_byte_buffer();
+
+    /* opal_vsnprintf */
+    test_vsnprintf_fits();
+    test_vsnprintf_truncation();
+    test_vsnprintf_length_equals_size_minus_one();
+    test_vsnprintf_length_equals_size();
+    test_vsnprintf_null_zero();
+
+    return test_finalize();
+}
diff --git a/test/util/opal_proc.c b/test/util/opal_proc.c
new file mode 100644
index 00000000000..0fc629075d9
--- /dev/null
+++ b/test/util/opal_proc.c
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for the opal proc / local-proc identity API:
+ *   opal_proc_local_get()  -- return the current local proc pointer
+ *   opal_proc_local_set()  -- replace the local proc pointer
+ *   opal_proc_set_name()   -- write a process name into the default local proc
+ *
+ * Behaviour from proc.c:
+ *   - A static opal_local_proc is always present; opal_proc_local_get()
+ *     returns &opal_local_proc by default (never NULL).
+ *   - opal_proc_local_set(p) retains p and releases the old pointer (unless
+ *     the old pointer is the built-in &opal_local_proc).
+ *   - opal_proc_local_set(NULL) restores the built-in default.
+ *   - opal_proc_set_name(name) copies name into the default local proc's
+ *     proc_name field using memcpy.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/proc.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <string.h>
+
+/* ------------------------------------------------------------------ */
+/* test_local_get_not_null                                            */
+/*                                                                     */
+/* opal_proc_local_get() must return non-NULL both before and after   */
+/* opal_init_util.  (We call it here, after init_util.)               */
+/* ------------------------------------------------------------------ */
+static void test_local_get_not_null(void)
+{
+    opal_proc_t *p = opal_proc_local_get();
+    test_verify("opal_proc_local_get() is non-NULL after init_util", NULL != p);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_local_set_get_roundtrip                                       */
+/*                                                                     */
+/* Create a new opal_proc_t, install it as the local proc, verify     */
+/* get returns the new pointer, then restore the default.             */
+/*                                                                     */
+/* Refcount protocol (from proc.c):                                   */
+/*   1. OBJ_NEW(proc_t)  -- refcount = 1 (our ref)                   */
+/*   2. local_set(p)     -- retains p   (refcount = 2)               */
+/*   3. local_set(NULL)  -- releases p  (refcount = 1)               */
+/*   4. OBJ_RELEASE(p)   -- refcount = 0 -> freed                    */
+/* ------------------------------------------------------------------ */
+static void test_local_set_get_roundtrip(void)
+{
+    opal_proc_t *original;
+    opal_proc_t *p;
+    opal_proc_t *got;
+    int rc;
+
+    original = opal_proc_local_get();
+
+    p = OBJ_NEW(opal_proc_t);
+    test_verify("OBJ_NEW(opal_proc_t) returns non-NULL", NULL != p);
+    if (NULL == p) {
+        return;
+    }
+
+    rc = opal_proc_local_set(p);
+    test_verify("opal_proc_local_set(p) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    got = opal_proc_local_get();
+    test_verify("opal_proc_local_get() returns the newly set proc", p == got);
+
+    /* Restore default: set(NULL) => reverts to &opal_local_proc */
+    rc = opal_proc_local_set(NULL);
+    test_verify("opal_proc_local_set(NULL) returns OPAL_SUCCESS", OPAL_SUCCESS == rc);
+
+    got = opal_proc_local_get();
+    test_verify("after set(NULL), get() returns original default",
+                original == got);
+
+    /* Release our own reference (the set/unset already handled the lib's ref). */
+    OBJ_RELEASE(p);
+}
+
+/* ------------------------------------------------------------------ */
+/* test_proc_set_name                                                  */
+/*                                                                     */
+/* opal_proc_set_name() copies a process name struct into the default */
+/* local proc.  We write a recognisable jobid/vpid pair and read it   */
+/* back through opal_proc_local_get()->proc_name.                     */
+/* ------------------------------------------------------------------ */
+static void test_proc_set_name(void)
+{
+    opal_process_name_t name;
+    opal_proc_t *lp;
+
+    /* Use values well within OPAL_JOBID_MAX / OPAL_VPID_MAX. */
+    name.jobid = 42;
+    name.vpid  = 7;
+
+    /* Make sure we are operating on the default local proc (no custom set). */
+    opal_proc_local_set(NULL);
+
+    opal_proc_set_name(&name);
+
+    lp = opal_proc_local_get();
+    test_verify("opal_proc_set_name: local proc non-NULL", NULL != lp);
+    if (NULL != lp) {
+        test_verify("opal_proc_set_name: jobid round-trips",
+                    (opal_jobid_t) 42 == lp->proc_name.jobid);
+        test_verify("opal_proc_set_name: vpid round-trips",
+                    (opal_vpid_t) 7 == lp->proc_name.vpid);
+    }
+}
+
+/* ------------------------------------------------------------------ */
+/* test_set_same_pointer_is_noop                                      */
+/*                                                                     */
+/* Setting the local proc to the current value (same pointer) must    */
+/* not double-retain or crash; it must still return OPAL_SUCCESS.     */
+/* ------------------------------------------------------------------ */
+static void test_set_same_pointer_is_noop(void)
+{
+    opal_proc_t *cur = opal_proc_local_get();
+    int rc = opal_proc_local_set(cur);
+    test_verify("opal_proc_local_set(same pointer) returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+    test_verify("opal_proc_local_get() unchanged after same-pointer set",
+                cur == opal_proc_local_get());
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    test_init("opal_proc");
+
+    opal_init_util(&argc, &argv);
+
+    test_local_get_not_null();
+    test_local_set_get_roundtrip();
+    test_proc_set_name();
+    test_set_same_pointer_is_noop();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_qsort.c b/test/util/opal_qsort.c
new file mode 100644
index 00000000000..66f4574ee8e
--- /dev/null
+++ b/test/util/opal_qsort.c
@@ -0,0 +1,231 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * opal_qsort is only compiled when OPAL_HAVE_BROKEN_QSORT is defined (non-zero).
+ * On platforms where the system qsort is fine, opal_qsort does not exist and
+ * including qsort.h directly emits a compile-time #error.  This file guards
+ * all opal_qsort usage inside #if OPAL_HAVE_BROKEN_QSORT so it still
+ * produces a valid (passing, no-op) test binary on those platforms.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+#include "opal/constants.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if OPAL_HAVE_BROKEN_QSORT
+
+#include "opal/util/qsort.h"
+
+/* -----------------------------------------------------------------------
+ * Comparator: ascending integer order (overflow-safe)
+ * ----------------------------------------------------------------------- */
+
+static int int_cmp(const void *a, const void *b)
+{
+    int ia = *(const int *) a;
+    int ib = *(const int *) b;
+
+    return (ia > ib) - (ia < ib);
+}
+
+/* -----------------------------------------------------------------------
+ * Helper: verify array is sorted in non-decreasing order
+ * ----------------------------------------------------------------------- */
+
+static int is_sorted(const int *arr, size_t n)
+{
+    size_t i;
+
+    for (i = 1; i < n; i++) {
+        if (arr[i] < arr[i - 1]) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+/* -----------------------------------------------------------------------
+ * Tests
+ * ----------------------------------------------------------------------- */
+
+static void test_empty_array(void)
+{
+    int arr[1]; /* unused memory; n=0 */
+
+    opal_qsort(arr, 0, sizeof(int), int_cmp);
+    test_verify("qsort empty array: no crash", 1);
+}
+
+static void test_single_element(void)
+{
+    int arr[1] = {42};
+
+    opal_qsort(arr, 1, sizeof(int), int_cmp);
+    test_verify("qsort single element: value preserved", 42 == arr[0]);
+}
+
+static void test_already_sorted(void)
+{
+    int arr[] = {1, 2, 3, 4, 5};
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+
+    opal_qsort(arr, n, sizeof(int), int_cmp);
+    test_verify("qsort already sorted", is_sorted(arr, n));
+}
+
+static void test_reverse_sorted(void)
+{
+    int arr[] = {5, 4, 3, 2, 1};
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+
+    opal_qsort(arr, n, sizeof(int), int_cmp);
+    test_verify("qsort reverse sorted: sorted", is_sorted(arr, n));
+    test_verify("qsort reverse sorted: arr[0]==1", 1 == arr[0]);
+    test_verify("qsort reverse sorted: arr[4]==5", 5 == arr[4]);
+}
+
+static void test_duplicates(void)
+{
+    int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+
+    opal_qsort(arr, n, sizeof(int), int_cmp);
+    test_verify("qsort duplicates: sorted", is_sorted(arr, n));
+    test_verify("qsort duplicates: arr[0]==1", 1 == arr[0]);
+    test_verify("qsort duplicates: arr[9]==9", 9 == arr[9]);
+}
+
+static void test_all_equal(void)
+{
+    int arr[] = {7, 7, 7, 7, 7};
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+
+    opal_qsort(arr, n, sizeof(int), int_cmp);
+    test_verify("qsort all equal: sorted", is_sorted(arr, n));
+    test_verify("qsort all equal: arr[0]==7", 7 == arr[0]);
+}
+
+static void test_two_elements_ordered(void)
+{
+    int arr[] = {1, 2};
+
+    opal_qsort(arr, 2, sizeof(int), int_cmp);
+    test_verify("qsort two elements ordered: arr[0]==1", 1 == arr[0]);
+    test_verify("qsort two elements ordered: arr[1]==2", 2 == arr[1]);
+}
+
+static void test_two_elements_reversed(void)
+{
+    int arr[] = {2, 1};
+
+    opal_qsort(arr, 2, sizeof(int), int_cmp);
+    test_verify("qsort two elements reversed: arr[0]==1", 1 == arr[0]);
+    test_verify("qsort two elements reversed: arr[1]==2", 2 == arr[1]);
+}
+
+static void test_negative_values(void)
+{
+    int arr[] = {0, -3, 5, -1, 2, -7};
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+
+    opal_qsort(arr, n, sizeof(int), int_cmp);
+    test_verify("qsort negative values: sorted", is_sorted(arr, n));
+    test_verify("qsort negative values: arr[0]==-7", -7 == arr[0]);
+    test_verify("qsort negative values: arr[5]==5", 5 == arr[5]);
+}
+
+/*
+ * Array > 40 elements exercises the median-of-3 pivot selection and recursive
+ * partition paths that are dead code for small inputs.
+ */
+static void test_large_array(void)
+{
+    /* 50 elements in reverse order */
+    int arr[50];
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+    size_t i;
+
+    for (i = 0; i < n; i++) {
+        arr[i] = (int)(n - i); /* 50, 49, ..., 1 */
+    }
+
+    opal_qsort(arr, n, sizeof(int), int_cmp);
+    test_verify("qsort large array (>40): sorted", is_sorted(arr, n));
+    test_verify("qsort large array: arr[0]==1", 1 == arr[0]);
+    test_verify("qsort large array: arr[49]==50", 50 == arr[49]);
+}
+
+static void test_large_array_random_like(void)
+{
+    /* 60 elements with varied values to cover all partition branches */
+    int arr[] = {
+        34, 7,  23, 32, 5,  62,  32, 78, 1,  88,
+        45, 21, 14, 57, 44, 99,  0,  -5, 33, 27,
+        19, 84, 65, 11, 36, 100, 72, 48, 56, 13,
+        93, 29, 8,  61, 41, 77,  52, 3,  66, 17,
+        39, 85, 24, 71, 46, 58,  12, 90, 37, 2,
+        55, 18, 43, 76, 31, 64,  9,  83, 50, 25
+    };
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+
+    opal_qsort(arr, n, sizeof(int), int_cmp);
+    test_verify("qsort large random-like (60 elems): sorted", is_sorted(arr, n));
+    test_verify("qsort large random-like: arr[0]==-5", -5 == arr[0]);
+    test_verify("qsort large random-like: arr[59]==100", 100 == arr[59]);
+}
+
+#endif /* OPAL_HAVE_BROKEN_QSORT */
+
+/* -----------------------------------------------------------------------
+ * main
+ * ----------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_qsort");
+
+#if OPAL_HAVE_BROKEN_QSORT
+    test_empty_array();
+    test_single_element();
+    test_already_sorted();
+    test_reverse_sorted();
+    test_duplicates();
+    test_all_equal();
+    test_two_elements_ordered();
+    test_two_elements_reversed();
+    test_negative_values();
+    test_large_array();
+    test_large_array_random_like();
+#else
+    test_comment("opal_qsort is not compiled on this platform (OPAL_HAVE_BROKEN_QSORT==0); "
+                 "tests skipped");
+    test_success();
+#endif
+
+    return test_finalize();
+}
diff --git a/test/util/opal_string_copy.c b/test/util/opal_string_copy.c
new file mode 100644
index 00000000000..d6c2682d905
--- /dev/null
+++ b/test/util/opal_string_copy.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include "support.h"
+#include "opal/util/string_copy.h"
+#include "opal/constants.h"
+
+int main(int argc, char *argv[])
+{
+    char dest[64];
+    const char *src;
+
+    test_init("opal_string_copy");
+
+    /* --- Normal: source shorter than dest_len --- */
+    memset(dest, 0xFF, sizeof(dest));
+    src = "hello";
+    opal_string_copy(dest, src, sizeof(dest));
+    test_verify("normal copy: content matches", 0 == strcmp(dest, "hello"));
+    test_verify("normal copy: NUL terminated", '\0' == dest[5]);
+
+    /* --- Exact fit: source length == dest_len - 1 (plus NUL = dest_len) --- */
+    memset(dest, 0xFF, sizeof(dest));
+    src = "abcde";          /* 5 chars + NUL = 6 bytes; dest_len=6 */
+    opal_string_copy(dest, src, 6);
+    test_verify("exact fit: content matches", 0 == strcmp(dest, "abcde"));
+    test_verify("exact fit: NUL at position 5", '\0' == dest[5]);
+
+    /* --- Truncation: source longer than dest_len --- */
+    memset(dest, 0xFF, sizeof(dest));
+    src = "abcdefghij";     /* 10 chars; dest_len=5 -> copy 4 chars + NUL */
+    opal_string_copy(dest, src, 5);
+    test_verify("truncation: dest[4] is NUL", '\0' == dest[4]);
+    test_verify("truncation: dest[3] is 'd'", 'd' == dest[3]);
+    test_verify("truncation: result is NUL-terminated string of 4 chars",
+                0 == strcmp(dest, "abcd"));
+
+    /* --- Truncation: dest_len == 1 -> result is empty string --- */
+    memset(dest, 0xFF, sizeof(dest));
+    src = "xyz";
+    opal_string_copy(dest, src, 1);
+    test_verify("len==1: dest[0] is NUL", '\0' == dest[0]);
+
+    /* --- Empty source string --- */
+    memset(dest, 0xFF, sizeof(dest));
+    src = "";
+    opal_string_copy(dest, src, sizeof(dest));
+    test_verify("empty src: dest[0] is NUL", '\0' == dest[0]);
+    test_verify("empty src: result is empty string", 0 == strcmp(dest, ""));
+
+    /* --- Source length exactly dest_len - 1 (another boundary check) --- */
+    memset(dest, 0xFF, sizeof(dest));
+    src = "A";              /* 1 char + NUL; dest_len=2 */
+    opal_string_copy(dest, src, 2);
+    test_verify("len=2 fit: content is 'A'", 'A' == dest[0]);
+    test_verify("len=2 fit: NUL at position 1", '\0' == dest[1]);
+
+    /* (The dest_len == 0 case -- previously an out-of-bounds write, now
+     * guarded in opal_string_copy() -- is exercised at the end of this
+     * file: "Zero-length dst: must write nothing and not crash".) */
+
+    /* --- Large but valid source (within 128K limit) --- */
+    {
+        char *big_src = (char *) malloc(1024);
+        char *big_dest = (char *) malloc(512);
+        if (NULL != big_src && NULL != big_dest) {
+            int i;
+            for (i = 0; i < 1023; ++i) {
+                big_src[i] = 'x';
+            }
+            big_src[1023] = '\0';
+            opal_string_copy(big_dest, big_src, 512);
+            test_verify("large src truncated: dest[511] is NUL", '\0' == big_dest[511]);
+            test_verify("large src truncated: first char is 'x'", 'x' == big_dest[0]);
+            free(big_src);
+            free(big_dest);
+        }
+    }
+
+    /* --- Zero-length destination: must write nothing and not crash --- */
+    {
+        char z[4] = {'a', 'b', 'c', 'd'};
+        opal_string_copy(z, "hello", 0);
+        test_verify("dest_len==0 leaves buffer untouched", 'a' == z[0]);
+    }
+
+    return test_finalize();
+}
diff --git a/test/util/opal_sys_limits.c b/test/util/opal_sys_limits.c
new file mode 100644
index 00000000000..4c29f0b97fb
--- /dev/null
+++ b/test/util/opal_sys_limits.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+/*
+ * Unit tests for opal_getpagesize() and opal_util_init_sys_limits().
+ *
+ * opal_getpagesize() wraps getpagesize() / sysconf(_SC_PAGESIZE) and caches
+ * the result.  A valid page size must be:
+ *   - positive
+ *   - a power of two (every real system page size is a power of two)
+ *   - equal to the value returned by sysconf(_SC_PAGESIZE)
+ *
+ * opal_util_init_sys_limits() reads opal_set_max_sys_limits (a module-level
+ * string from opal_params).  With the default configuration from
+ * opal_init_util(), opal_set_max_sys_limits is NULL, so the function returns
+ * OPAL_SUCCESS immediately without touching *errmsg.
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+
+#include "opal/util/sys_limits.h"
+#include "opal/constants.h"
+#include "opal/runtime/opal.h"
+
+#include <unistd.h>
+#include <stdlib.h>
+
+/* ------------------------------------------------------------------ */
+/* helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+/* Returns 1 if n is a positive power of two, 0 otherwise. */
+static int is_power_of_two(int n)
+{
+    if (n <= 0) {
+        return 0;
+    }
+    return 0 == (n & (n - 1));
+}
+
+static void test_getpagesize(void)
+{
+    int ps;
+    long sc_ps;
+
+    ps = opal_getpagesize();
+    test_verify("opal_getpagesize() returns positive value", ps > 0);
+    test_verify("opal_getpagesize() returns a power of two", is_power_of_two(ps));
+
+    /* Compare to sysconf(_SC_PAGESIZE) which is the authoritative source
+     * on POSIX systems.  sysconf() may legally return -1 (unsupported or
+     * error), in which case there is nothing to compare against and we
+     * simply skip this check rather than failing a correct
+     * opal_getpagesize(). */
+    sc_ps = sysconf(_SC_PAGESIZE);
+    if (sc_ps > 0) {
+        test_verify("opal_getpagesize() matches sysconf(_SC_PAGESIZE)",
+                    (long) ps == sc_ps);
+    } else {
+        test_comment("sysconf(_SC_PAGESIZE) unavailable; skipping comparison");
+    }
+
+    /* Second call must return the same (cached) value. */
+    test_verify("opal_getpagesize() is idempotent", ps == opal_getpagesize());
+}
+
+static void test_init_sys_limits_default(void)
+{
+    /*
+     * With opal_set_max_sys_limits == NULL (the default set by opal_init_util),
+     * opal_util_init_sys_limits() returns OPAL_SUCCESS immediately.
+     * The errmsg pointer must not be written in this case; we pass NULL to
+     * confirm the function doesn't dereference it when there is nothing to do.
+     */
+    int rc = opal_util_init_sys_limits(NULL);
+    test_verify("opal_util_init_sys_limits(NULL limits) returns OPAL_SUCCESS",
+                OPAL_SUCCESS == rc);
+}
+
+static void test_init_sys_limits_errmsg_untouched(void)
+{
+    /*
+     * Pass a valid errmsg pointer initialised to NULL; confirm it stays NULL
+     * when opal_set_max_sys_limits is NULL (nothing to process).
+     */
+    char *errmsg = NULL;
+    int rc = opal_util_init_sys_limits(&errmsg);
+    test_verify("opal_util_init_sys_limits: rc == OPAL_SUCCESS", OPAL_SUCCESS == rc);
+    test_verify("opal_util_init_sys_limits: errmsg untouched when no limits set",
+                NULL == errmsg);
+}
+
+/* ------------------------------------------------------------------ */
+/* main                                                                */
+/* ------------------------------------------------------------------ */
+
+int main(int argc, char *argv[])
+{
+    int r;
+
+    test_init("opal_sys_limits");
+
+    /* test_init_sys_limits_default() passes a NULL errmsg and relies on
+       opal_set_max_sys_limits being NULL (its default) so the call is a
+       no-op.  An inherited OMPI_MCA_opal_set_max_sys_limits would make it
+       non-NULL, taking the processing path (which could dereference the NULL
+       errmsg).  Clear it so the default-path assumption holds. */
+    unsetenv("OMPI_MCA_opal_set_max_sys_limits");
+
+    opal_init_util(&argc, &argv);
+
+    test_getpagesize();
+    test_init_sys_limits_default();
+    test_init_sys_limits_errmsg_untouched();
+
+    r = test_finalize();
+    opal_finalize_util();
+    return r;
+}
diff --git a/test/util/opal_timer.c b/test/util/opal_timer.c
index d277861b215..06fe00b67c4 100644
--- a/test/util/opal_timer.c
+++ b/test/util/opal_timer.c
@@ -20,14 +20,20 @@
 
 #include <unistd.h>
 
+#include "opal/constants.h"
 #include "opal/mca/timer/base/base.h"
 #include "opal/runtime/opal.h"
 
 int main(int argc, char *argv[])
 {
     opal_timer_t start, end, diff;
+    int rc;
 
-    opal_init(&argc, &argv);
+    rc = opal_init(&argc, &argv);
+    if (OPAL_SUCCESS != rc) {
+        fprintf(stderr, "opal_init() failed: %d\n", rc);
+        return 1;
+    }
 
     printf("--> frequency: %llu\n", (unsigned long long) opal_timer_base_get_freq());
 
diff --git a/test/util/opal_uri.c b/test/util/opal_uri.c
new file mode 100644
index 00000000000..2d085d5d9de
--- /dev/null
+++ b/test/util/opal_uri.c
@@ -0,0 +1,342 @@
+/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
+/*
+ * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
+ *                         University Research and Technology
+ *                         Corporation.  All rights reserved.
+ * Copyright (c) 2004-2005 The University of Tennessee and The University
+ *                         of Tennessee Research Foundation.  All rights
+ *                         reserved.
+ * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
+ *                         University of Stuttgart.  All rights reserved.
+ * Copyright (c) 2004-2005 The Regents of the University of California.
+ *                         All rights reserved.
+ * Copyright (c) 2026      Jeffrey M. Squyres.  All rights reserved.
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ */
+
+#include "opal_config.h"
+
+#include "support.h"
+#include "opal/util/uri.h"
+#include "opal/constants.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* -----------------------------------------------------------------------
+ * opal_uri_get_scheme
+ * ----------------------------------------------------------------------- */
+
+static void test_get_scheme_file(void)
+{
+    char *scheme;
+
+    scheme = opal_uri_get_scheme("file:///tmp/foo");
+    test_verify("get_scheme file:///tmp/foo returns 'file'",
+                NULL != scheme && 0 == strcmp("file", scheme));
+    free(scheme);
+}
+
+static void test_get_scheme_http(void)
+{
+    char *scheme;
+
+    scheme = opal_uri_get_scheme("http://example.com/path");
+    test_verify("get_scheme http://... returns 'http'",
+                NULL != scheme && 0 == strcmp("http", scheme));
+    free(scheme);
+}
+
+static void test_get_scheme_custom(void)
+{
+    char *scheme;
+
+    scheme = opal_uri_get_scheme("myscheme://host/resource");
+    test_verify("get_scheme myscheme://... returns 'myscheme'",
+                NULL != scheme && 0 == strcmp("myscheme", scheme));
+    free(scheme);
+}
+
+static void test_get_scheme_malformed(void)
+{
+    char *scheme;
+
+    /* No colon -> documented to return NULL */
+    scheme = opal_uri_get_scheme("nocolon");
+    test_verify("get_scheme malformed (no colon) returns NULL", NULL == scheme);
+    /* scheme is NULL; nothing to free */
+}
+
+/* -----------------------------------------------------------------------
+ * opal_filename_to_uri  (NULL hostname = local file)
+ * ----------------------------------------------------------------------- */
+
+static void test_to_uri_local_simple(void)
+{
+    char *uri;
+
+    uri = opal_filename_to_uri("/tmp/foo.txt", NULL);
+    test_verify("to_uri /tmp/foo.txt local: not NULL", NULL != uri);
+    test_verify("to_uri /tmp/foo.txt local: == 'file:///tmp/foo.txt'",
+                NULL != uri && 0 == strcmp("file:///tmp/foo.txt", uri));
+    free(uri);
+}
+
+static void test_to_uri_local_deep_path(void)
+{
+    char *uri;
+
+    uri = opal_filename_to_uri("/a/b/c/d.dat", NULL);
+    test_verify("to_uri /a/b/c/d.dat local: == 'file:///a/b/c/d.dat'",
+                NULL != uri && 0 == strcmp("file:///a/b/c/d.dat", uri));
+    free(uri);
+}
+
+static void test_to_uri_relative_path(void)
+{
+    char *uri;
+
+    /* A relative path is not allowed; function must return NULL */
+    uri = opal_filename_to_uri("relative/path", NULL);
+    test_verify("to_uri relative path returns NULL", NULL == uri);
+}
+
+static void test_to_uri_with_hostname(void)
+{
+    char *uri;
+
+    uri = opal_filename_to_uri("/data/file.txt", "myhost");
+    test_verify("to_uri with hostname: not NULL", NULL != uri);
+    /* Expected: file://myhost/data/file.txt */
+    test_verify("to_uri with hostname: correct URI",
+                NULL != uri && 0 == strcmp("file://myhost/data/file.txt", uri));
+    free(uri);
+}
+
+/* -----------------------------------------------------------------------
+ * opal_filename_from_uri
+ * ----------------------------------------------------------------------- */
+
+static void test_from_uri_local_triple_slash(void)
+{
+    char *fn;
+    char *host = (char *) "sentinel"; /* should be set to NULL */
+
+    fn = opal_filename_from_uri("file:///tmp/foo.txt", &host);
+    test_verify("from_uri file:///tmp/foo.txt: filename not NULL", NULL != fn);
+    test_verify("from_uri file:///tmp/foo.txt: == '/tmp/foo.txt'",
+                NULL != fn && 0 == strcmp("/tmp/foo.txt", fn));
+    test_verify("from_uri file:///tmp/foo.txt: host is NULL", NULL == host);
+    free(fn);
+    /* host is NULL; nothing to free */
+}
+
+static void test_from_uri_with_hostname(void)
+{
+    char *fn;
+    char *host = NULL;
+
+    fn = opal_filename_from_uri("file://myhost/data/file.txt", &host);
+    test_verify("from_uri with hostname: filename not NULL", NULL != fn);
+    test_verify("from_uri with hostname: == '/data/file.txt'",
+                NULL != fn && 0 == strcmp("/data/file.txt", fn));
+    test_verify("from_uri with hostname: host == 'myhost'",
+                NULL != host && 0 == strcmp("myhost", host));
+    free(fn);
+    free(host);
+}
+
+static void test_from_uri_hostname_param_null(void)
+{
+    char *fn;
+
+    /* Documented: passing NULL for hostname is valid */
+    fn = opal_filename_from_uri("file:///tmp/bar", NULL);
+    test_verify("from_uri NULL hostname param: filename not NULL", NULL != fn);
+    test_verify("from_uri NULL hostname param: == '/tmp/bar'",
+                NULL != fn && 0 == strcmp("/tmp/bar", fn));
+    free(fn);
+}
+
+static void test_from_uri_malformed_no_colon(void)
+{
+    char *fn;
+
+    fn = opal_filename_from_uri("nocolon", NULL);
+    test_verify("from_uri malformed (no colon) returns NULL", NULL == fn);
+}
+
+static void test_from_uri_malformed_single_slash(void)
+{
+    char *fn;
+
+    /* "file:/x" has only one slash after ':' -- not "//", not "///" */
+    fn = opal_filename_from_uri("file:/x", NULL);
+    test_verify("from_uri malformed (single slash) returns NULL", NULL == fn);
+}
+
+static void test_from_uri_malformed_no_path_slash(void)
+{
+    char *fn;
+
+    /* "file://hostonly" has no '/' to separate host from path */
+    fn = opal_filename_from_uri("file://hostonly", NULL);
+    test_verify("from_uri malformed (no path slash) returns NULL", NULL == fn);
+}
+
+/* -----------------------------------------------------------------------
+ * Round-trip: path -> URI -> path (local, no hostname)
+ * ----------------------------------------------------------------------- */
+
+static void test_roundtrip_local(void)
+{
+    const char *original = "/usr/local/bin/mpirun";
+    char *uri;
+    char *recovered;
+    char *host = (char *) "sentinel";
+
+    uri = opal_filename_to_uri(original, NULL);
+    test_verify("roundtrip local: to_uri not NULL", NULL != uri);
+
+    recovered = opal_filename_from_uri(uri, &host);
+    test_verify("roundtrip local: from_uri not NULL", NULL != recovered);
+    test_verify("roundtrip local: recovered == original",
+                NULL != recovered && 0 == strcmp(original, recovered));
+    test_verify("roundtrip local: host is NULL after from_uri", NULL == host);
+
+    free(uri);
+    free(recovered);
+}
+
+/* -----------------------------------------------------------------------
+ * Round-trip: path -> URI -> path (with hostname)
+ * ----------------------------------------------------------------------- */
+
+static void test_roundtrip_with_hostname(void)
+{
+    const char *original = "/home/user/data.txt";
+    const char *hostname_in = "compute01";
+    char *uri;
+    char *recovered;
+    char *host = NULL;
+
+    uri = opal_filename_to_uri(original, hostname_in);
+    test_verify("roundtrip hostname: to_uri not NULL", NULL != uri);
+
+    recovered = opal_filename_from_uri(uri, &host);
+    test_verify("roundtrip hostname: from_uri not NULL", NULL != recovered);
+    test_verify("roundtrip hostname: recovered == original",
+                NULL != recovered && 0 == strcmp(original, recovered));
+    test_verify("roundtrip hostname: host == hostname_in",
+                NULL != host && 0 == strcmp(hostname_in, host));
+
+    free(uri);
+    free(recovered);
+    free(host);
+}
+
+/* -----------------------------------------------------------------------
+ * get_scheme on a file:// URI
+ * ----------------------------------------------------------------------- */
+
+static void test_get_scheme_on_file_uri(void)
+{
+    char *uri;
+    char *scheme;
+
+    uri = opal_filename_to_uri("/etc/passwd", NULL);
+    test_verify("get_scheme on built URI: uri not NULL", NULL != uri);
+
+    scheme = opal_uri_get_scheme(uri);
+    test_verify("get_scheme on built URI: == 'file'",
+                NULL != scheme && 0 == strcmp("file", scheme));
+
+    free(uri);
+    free(scheme);
+}
+
+/* -----------------------------------------------------------------------
+ * reserved-char escaping preserves every filename character
+ *
+ * opal_filename_to_uri escapes reserved chars when a hostname is present
+ * by prefixing each with a backslash.  A previous off-by-one in the
+ * escaping loop (`k < strlen(filename) - 1`) dropped the last character
+ * of the filename whenever escaping occurred; e.g. "/a;b/c" produced
+ * "file://host/a\;b/" (the trailing 'c' was lost).  This test asserts the
+ * full, correct result so the bound stays fixed.
+ * ----------------------------------------------------------------------- */
+
+static void test_to_uri_reserved_char_escaping(void)
+{
+    const char *original = "/a;b/c";
+    const char *expected = "file://host/a\\;b/c";
+    char *uri;
+
+    uri = opal_filename_to_uri(original, "host");
+    test_verify("to_uri with reserved char (';'): uri not NULL", NULL != uri);
+    /* The reserved ';' is backslash-escaped and no characters are dropped. */
+    test_verify("to_uri with reserved char (';'): escapes and preserves all chars",
+                NULL != uri && 0 == strcmp(expected, uri));
+    free(uri);
+
+    /*
+     * A reserved character that repeats is escaped at every occurrence, so
+     * the output can grow to 2 bytes per input character.  This exercises
+     * the buffer sizing (each ';' adds a backslash) and confirms no
+     * characters are dropped.
+     */
+    original = "/a;b;c";
+    expected = "file://host/a\\;b\\;c";
+    uri = opal_filename_to_uri(original, "host");
+    test_verify("to_uri with repeated reserved char: uri not NULL", NULL != uri);
+    test_verify("to_uri with repeated reserved char: escapes each occurrence",
+                NULL != uri && 0 == strcmp(expected, uri));
+    free(uri);
+}
+
+/* -----------------------------------------------------------------------
+ * main
+ * ----------------------------------------------------------------------- */
+
+int main(int argc, char *argv[])
+{
+    (void) argc;
+    (void) argv;
+
+    test_init("opal_uri");
+
+    /* opal_uri_get_scheme */
+    test_get_scheme_file();
+    test_get_scheme_http();
+    test_get_scheme_custom();
+    test_get_scheme_malformed();
+
+    /* opal_filename_to_uri */
+    test_to_uri_local_simple();
+    test_to_uri_local_deep_path();
+    test_to_uri_relative_path();
+    test_to_uri_with_hostname();
+
+    /* opal_filename_from_uri */
+    test_from_uri_local_triple_slash();
+    test_from_uri_with_hostname();
+    test_from_uri_hostname_param_null();
+    test_from_uri_malformed_no_colon();
+    test_from_uri_malformed_single_slash();
+    test_from_uri_malformed_no_path_slash();
+
+    /* Round-trips */
+    test_roundtrip_local();
+    test_roundtrip_with_hostname();
+    test_get_scheme_on_file_uri();
+
+    /* Suspected-bug coverage */
+    test_to_uri_reserved_char_escaping();
+
+    return test_finalize();
+}