UCT/ROCM: Enable dmabuf by default with peermem fallback Use dma-buf for GPU-direct when the kernel supports it, and keep peermem as the fallback on older kernels. Also report allocation-base offsets for interior ROCm addresses.

Author: ddebonis-amd

AUTHORS

@@ -24,6 +24,7 @@ Changcheng Liu <jerrliu@nvidia.com>
 Colin Hirsch <chirsch@nvidia.com>
 Corey J. Nolet <cjnolet@gmail.com>
 Daniel Pressler <danielpr@nvidia.com>
+David DeBonis <ddebonis@amd.com>
 David Wootton <dwootton@us.ibm.com>
 Devendar Bureddy <devendar@mellanox.com>
 Devesh Sharma <devesh.sharma@broadcom.com>

NEWS

@@ -9,9 +9,13 @@
 
 ## Current
 ### Features:
+#### ROCM
+ * Enabled dmabuf by default for GPU-direct transfers, falling back to peermem when unavailable
 #### RDMA CORE (IB, ROCE, etc.)
  * UCX_IB_PCI_RELAXED_ORDERING=yes now requires all memory keys to use relaxed ordering and omits strict-order companion keys; the former "only" value is removed
 ### Bugfixes:
+#### ROCM
+ * Fixed dmabuf base address and offset for interior ROCm pointers
 
 ## 1.22.0 (August 2, 2026)
 ### Features:

src/uct/rocm/base/rocm_base.c

@@ -12,7 +12,9 @@
 
 #include <ucs/sys/string.h>
 #include <ucs/sys/module.h>
+#include <ucs/sys/sock.h>
 #include <ucs/memory/memtype_cache.h>
+#include <ucs/type/init_once.h>
 #include <sys/utsname.h>
 #include <pthread.h>
 
@@ -333,9 +335,8 @@ FILE* uct_rocm_base_load_kernel_config_file()
 
 int uct_rocm_base_file_contains_dmabuf_support(FILE* fp, const char kernel_opt1[], const char kernel_opt2[])
 {
-    int dmabuf_supported = 0;
-    int found_opt1           = 0;
-    int found_opt2           = 0;
+    int found_opt1 = 0;
+    int found_opt2 = 0;
     char buf[256];
 
     while (fgets(buf, sizeof(buf), fp) != NULL) {
@@ -346,10 +347,10 @@ int uct_rocm_base_file_contains_dmabuf_support(FILE* fp, const char kernel_opt1[
             found_opt2 = 1;
         }
         if (found_opt1 && found_opt2) {
-            dmabuf_supported = 1;
+            return 1;
         }
     }
-    return dmabuf_supported;
+    return 0;
 }
 
 int uct_rocm_base_kernel_config_supports_dmabuf()
@@ -388,16 +389,24 @@ int uct_rocm_base_kernel_symbols_supports_dmabuf()
 
 int uct_rocm_base_is_dmabuf_supported()
 {
-#if HAVE_HSA_AMD_PORTABLE_EXPORT_DMABUF    
-    if (uct_rocm_base_kernel_config_supports_dmabuf()) {
-        return 1;
-    }
+    static ucs_init_once_t init_once = UCS_INIT_ONCE_INITIALIZER;
+    static int dmabuf_supported      = 0;
 
-    ucs_trace("no kernel conf file found or no support for dmabuf found, trying /proc/kallsyms fallback");
-    return uct_rocm_base_kernel_symbols_supports_dmabuf();
-#else
-    return 0;
+    UCS_INIT_ONCE(&init_once) {
+#if HAVE_HSA_AMD_PORTABLE_EXPORT_DMABUF
+        if (uct_rocm_base_kernel_config_supports_dmabuf()) {
+            dmabuf_supported = 1;
+        } else {
+            ucs_trace("no kernel conf file found or no support for dmabuf "
+                      "found, trying /proc/kallsyms fallback");
+            dmabuf_supported = uct_rocm_base_kernel_symbols_supports_dmabuf();
+        }
 #endif
+        ucs_debug("dmabuf is%s supported on ROCm",
+                  dmabuf_supported ? "" : " not");
+    }
+
+    return dmabuf_supported;
 }
 
 static void uct_rocm_base_dmabuf_export(const void *addr, const size_t length,
@@ -414,8 +423,8 @@ static void uct_rocm_base_dmabuf_export(const void *addr, const size_t length,
         if (status != HSA_STATUS_SUCCESS) {
             fd     = UCT_DMABUF_FD_INVALID;
             offset = 0;
-            ucs_warn("failed to export dmabuf handle for addr %p / %zu", addr,
-                     length);
+            ucs_debug("failed to export dmabuf handle for addr %p / %zu: 0x%x",
+                      addr, length, status);
         }
 
         ucs_trace("dmabuf export addr %p %lu to dmabuf fd %d offset %zu\n",
@@ -427,14 +436,13 @@ static void uct_rocm_base_dmabuf_export(const void *addr, const size_t length,
 }
 
 ucs_status_t uct_rocm_base_mem_query(uct_md_h md, const void *addr,
-                                     const size_t length,
+                                     size_t length, int have_dmabuf,
                                      uct_md_mem_attr_v2_t *mem_attr_p)
 {
     size_t dmabuf_offset       = 0;
-    int is_exported            = 0;
     ucs_memory_type_t mem_type = UCS_MEMORY_TYPE_HOST;
     ucs_sys_device_t sys_dev   = UCS_SYS_DEVICE_ID_UNKNOWN;
-    int dmabuf_fd;
+    int dmabuf_fd              = UCT_DMABUF_FD_INVALID;
     hsa_status_t status;
     hsa_device_type_t dev_type;
     hsa_amd_pointer_type_t hsa_mem_type;
@@ -447,7 +455,7 @@ ucs_status_t uct_rocm_base_mem_query(uct_md_h md, const void *addr,
                                         &base_size, &hsa_mem_type, &agent,
                                         &dev_type);
     if (status != HSA_STATUS_SUCCESS) {
-        return status;
+        return UCS_ERR_INVALID_ADDR;
     }
 
     if ((hsa_mem_type == HSA_EXT_POINTER_TYPE_HSA) &&
@@ -458,6 +466,9 @@ ucs_status_t uct_rocm_base_mem_query(uct_md_h md, const void *addr,
         if (ucs_status != UCS_OK) {
             sys_dev = UCS_SYS_DEVICE_ID_UNKNOWN;
         }
+    } else {
+        base_addr = (void*)addr;
+        base_size = length;
     }
 
     if (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_MEM_TYPE) {
@@ -469,26 +480,30 @@ ucs_status_t uct_rocm_base_mem_query(uct_md_h md, const void *addr,
     }
 
     if (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_BASE_ADDRESS) {
-        mem_attr_p->base_address = (void*) addr;
+        mem_attr_p->base_address = base_addr;
     }
 
     if (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_ALLOC_LENGTH) {
-        mem_attr_p->alloc_length = length;
+        mem_attr_p->alloc_length = base_size;
     }
 
-    if (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_DMABUF_FD) {
-        uct_rocm_base_dmabuf_export(addr, length, mem_type, &dmabuf_fd,
-                                    &dmabuf_offset);
-        mem_attr_p->dmabuf_fd = dmabuf_fd;
-        is_exported           = 1;
-    }
+    if ((mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_DMABUF_FD) ||
+        (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_DMABUF_OFFSET)) {
+        if (have_dmabuf) {
+            uct_rocm_base_dmabuf_export(base_addr, base_size, mem_type,
+                                        &dmabuf_fd, &dmabuf_offset);
+        }
+
+        if (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_DMABUF_FD) {
+            mem_attr_p->dmabuf_fd = dmabuf_fd;
+        } else {
+            ucs_close_fd(&dmabuf_fd);
+        }
 
-    if (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_DMABUF_OFFSET) {
-        if (!is_exported) {
-            uct_rocm_base_dmabuf_export(addr, length, mem_type, &dmabuf_fd,
-                                        &dmabuf_offset);
+        if (mem_attr_p->field_mask & UCT_MD_MEM_ATTR_V2_FIELD_DMABUF_OFFSET) {
+            mem_attr_p->dmabuf_offset = dmabuf_offset +
+                                        UCS_PTR_BYTE_DIFF(base_addr, addr);
         }
-        mem_attr_p->dmabuf_offset = dmabuf_offset;
     }
 
     if (mem_type == UCS_MEMORY_TYPE_ROCM) {

src/uct/rocm/base/rocm_base.h

@@ -41,7 +41,7 @@ ucs_status_t uct_rocm_base_detect_memory_type(uct_md_h md, const void *addr,
                                               size_t length,
                                               ucs_memory_type_t *mem_type_p);
 ucs_status_t uct_rocm_base_mem_query(uct_md_h md, const void *addr,
-                                     const size_t length,
+                                     size_t length, int have_dmabuf,
                                      uct_md_mem_attr_v2_t *mem_attr_p);
 ucs_status_t uct_rocm_base_get_link_type(hsa_amd_link_info_type_t *type);
 uct_rocm_amd_gpu_product_t uct_rocm_base_get_gpu_product(void);

src/uct/rocm/copy/rocm_copy_md.c

@@ -36,7 +36,7 @@ static ucs_config_field_t uct_rocm_copy_md_config_table[] = {
      ucs_offsetof(uct_rocm_copy_md_config_t, rcache),
      UCS_CONFIG_TYPE_TABLE(ucs_config_rcache_table)},
 
-    {"DMABUF", "no",
+    {"DMABUF", "try",
      "Enable using cross-device dmabuf file descriptor",
      ucs_offsetof(uct_rocm_copy_md_config_t, enable_dmabuf),
      UCS_CONFIG_TYPE_TERNARY},
@@ -282,6 +282,16 @@ static ucs_status_t uct_rocm_copy_mem_free(uct_md_h md, uct_mem_h memh)
     return UCS_OK;
 }
 
+static ucs_status_t
+uct_rocm_copy_mem_query(uct_md_h uct_md, const void *addr, size_t length,
+                        uct_md_mem_attr_v2_t *mem_attr_p)
+{
+    uct_rocm_copy_md_t *md = ucs_derived_of(uct_md, uct_rocm_copy_md_t);
+
+    return uct_rocm_base_mem_query(uct_md, addr, length, md->have_dmabuf,
+                                   mem_attr_p);
+}
+
 static uct_md_ops_t md_ops = {
     .close              = uct_rocm_copy_md_close,
     .query              = uct_rocm_copy_md_query,
@@ -290,7 +300,7 @@ static uct_md_ops_t md_ops = {
     .mem_advise         = (uct_md_mem_advise_func_t)ucs_empty_function_return_unsupported,
     .mem_reg            = uct_rocm_copy_mem_reg,
     .mem_dereg          = uct_rocm_copy_mem_dereg,
-    .mem_query          = uct_rocm_base_mem_query,
+    .mem_query          = uct_rocm_copy_mem_query,
     .mkey_pack          = uct_rocm_copy_mkey_pack,
     .mem_attach         = (uct_md_mem_attach_func_t)ucs_empty_function_return_unsupported,
     .detect_memory_type = uct_rocm_base_detect_memory_type,
@@ -351,7 +361,7 @@ static uct_md_ops_t md_rcache_ops = {
     .mem_advise         = (uct_md_mem_advise_func_t)ucs_empty_function_return_unsupported,
     .mem_reg            = uct_rocm_copy_mem_rcache_reg,
     .mem_dereg          = uct_rocm_copy_mem_rcache_dereg,
-    .mem_query          = uct_rocm_base_mem_query,
+    .mem_query          = uct_rocm_copy_mem_query,
     .mkey_pack          = uct_rocm_copy_mkey_pack,
     .mem_attach         = (uct_md_mem_attach_func_t)ucs_empty_function_return_unsupported,
     .detect_memory_type = uct_rocm_base_detect_memory_type,
@@ -428,7 +438,8 @@ uct_rocm_copy_md_open(uct_component_h component, const char *md_name,
     have_dmabuf = uct_rocm_base_is_dmabuf_supported();
     if ((md_config->enable_dmabuf == UCS_YES) && !have_dmabuf) {
         ucs_error("ROCm dmabuf support requested but not found");
-        return UCS_ERR_UNSUPPORTED;
+        status = UCS_ERR_UNSUPPORTED;
+        goto err;
     }
 
     if (md_config->enable_dmabuf != UCS_NO) {

test/gtest/uct/test_md.cc

@@ -542,10 +542,16 @@ UCS_TEST_P(test_md, mem_type_detect_mds) {
             ASSERT_UCS_OK(status);
             EXPECT_EQ(alloc_mem_type, mem_attr.mem_type);
             if ((alloc_mem_type == UCS_MEMORY_TYPE_CUDA) ||
+                (alloc_mem_type == UCS_MEMORY_TYPE_ROCM) ||
                 (alloc_mem_type == UCS_MEMORY_TYPE_ZE_HOST) ||
                 (alloc_mem_type == UCS_MEMORY_TYPE_ZE_DEVICE) ||
                 (alloc_mem_type == UCS_MEMORY_TYPE_ZE_MANAGED)) {
-                EXPECT_EQ(buffer_size, mem_attr.alloc_length);
+                /* ROCm HSA may round sizeInBytes up to a page */
+                if (alloc_mem_type == UCS_MEMORY_TYPE_ROCM) {
+                    EXPECT_GE(mem_attr.alloc_length, buffer_size);
+                } else {
+                    EXPECT_EQ(buffer_size, mem_attr.alloc_length);
+                }
                 EXPECT_EQ(address, mem_attr.base_address);
             } else {
                 EXPECT_EQ(slice_length, mem_attr.alloc_length);
@@ -1277,6 +1283,30 @@ UCS_TEST_P(test_md_dmabuf, mem_query_dmabuf)
 
 UCT_MD_INSTANTIATE_TEST_CASE(test_md_dmabuf)
 
+class test_rocm_copy : public test_md {
+};
+
+UCS_TEST_P(test_rocm_copy, dmabuf_disable, "ROCM_COPY_DMABUF=no")
+{
+    EXPECT_EQ(0, md_attr().dmabuf_mem_types);
+    if (!(md_attr().access_mem_types & UCS_BIT(UCS_MEMORY_TYPE_ROCM)) ||
+        !mem_buffer::is_mem_type_supported(UCS_MEMORY_TYPE_ROCM)) {
+        UCS_TEST_SKIP_R("ROCm memory is not supported");
+    }
+
+    mem_buffer mem_buf(ucs_get_page_size(), UCS_MEMORY_TYPE_ROCM);
+    uct_md_mem_attr_t mem_attr = {};
+
+    mem_attr.field_mask = UCT_MD_MEM_ATTR_FIELD_DMABUF_FD |
+                          UCT_MD_MEM_ATTR_FIELD_DMABUF_OFFSET;
+    ASSERT_UCS_OK(uct_md_mem_query(md(), mem_buf.ptr(), mem_buf.size(),
+                                   &mem_attr));
+    EXPECT_EQ(UCT_DMABUF_FD_INVALID, mem_attr.dmabuf_fd);
+    EXPECT_EQ(0ul, mem_attr.dmabuf_offset);
+}
+
+_UCT_MD_INSTANTIATE_TEST_CASE(test_rocm_copy, rocm_cpy)
+
 class test_cuda : public test_md
 {
 };