Add interface func and test

Author: sunge666-ui

flagcx/adaptor/device/kunlunxin_adaptor.cc

@@ -103,6 +103,9 @@ flagcxResult_t kunlunAdaptorGetVendor(char *vendor) {
 }
 
 flagcxResult_t kunlunAdaptorHostGetDevicePointer(void **pDevice, void *pHost) {
+  if (pDevice == NULL || pHost == NULL) {
+    return flagcxInvalidArgument;
+  }
   DEVCHECK(cudaHostGetDevicePointer(pDevice, pHost, 0));
   return flagcxSuccess;
 }
@@ -331,16 +334,29 @@ flagcxResult_t kunlunAdaptorGetDeviceProperties(struct flagcxDevProps *props,
     return flagcxInvalidArgument;
   }
 
+  // Get device name via cudaGetDeviceProperties
   cudaDeviceProp devProp;
   DEVCHECK(cudaGetDeviceProperties(&devProp, dev));
   strncpy(props->name, devProp.name, sizeof(props->name) - 1);
   props->name[sizeof(props->name) - 1] = '\0';
-  props->pciBusId = devProp.pciBusID;
-  props->pciDeviceId = devProp.pciDeviceID;
-  props->pciDomainId = devProp.pciDomainID;
-  // TODO: see if there's another way to get this info. In some cuda versions,
-  // cudaDeviceProp does not have `gpuDirectRDMASupported` field
-  // props->gdrSupported = devProp.gpuDirectRDMASupported;
+
+  // XPU runtime does not write PCI fields in cudaDeviceProp.
+  // Parse them from the stable PCI bus ID string instead.
+  char pciBusIdStr[FLAGCX_DEVICE_PCI_BUSID_BUFFER_SIZE] = {};
+  DEVCHECK(cudaDeviceGetPCIBusId(pciBusIdStr, sizeof(pciBusIdStr), dev));
+
+  // Format: "DDDD:BB:SS.F"
+  unsigned int domain = 0, bus = 0, slot = 0, func = 0;
+  if (sscanf(pciBusIdStr, "%x:%x:%x.%x", &domain, &bus, &slot, &func) != 4) {
+    return flagcxInternalError;
+  }
+  if (domain > 0xffff || bus > 0xff || slot > 0x1f || func > 0x7) {
+    return flagcxInternalError;
+  }
+
+  props->pciDomainId = static_cast<int>(domain);
+  props->pciBusId    = static_cast<int>(bus);
+  props->pciDeviceId = static_cast<int>(slot);
 
   return flagcxSuccess;
 }
@@ -371,16 +387,30 @@ flagcxResult_t kunlunAdaptorStreamWriteValue64(flagcxStream_t, void *, uint64_t,
                                                int) {
   return flagcxNotSupported;
 }
-flagcxResult_t kunlunAdaptorEventElapsedTime(float *, flagcxEvent_t,
-                                             flagcxEvent_t) {
-  return flagcxNotSupported;
+flagcxResult_t kunlunAdaptorEventElapsedTime(float *ms, flagcxEvent_t start,
+                                             flagcxEvent_t end) {
+  if (ms == NULL || start == NULL || end == NULL) {
+    return flagcxInvalidArgument;
+  }
+  DEVCHECK(cudaEventElapsedTime(ms, start->base, end->base));
+  return flagcxSuccess;
 }
 
-flagcxResult_t kunlunAdaptorHostRegister(void *, size_t) {
-  return flagcxNotSupported;
+flagcxResult_t kunlunAdaptorHostRegister(void *ptr, size_t size) {
+  if (ptr == NULL || size == 0) {
+    return flagcxInvalidArgument;
+  }
+  // XPU's cudaHostRegisterMapped triggers a runtime assertion crash
+  // (rm_mem.cc:2284), so use Default flag to register as page-locked memory.
+  DEVCHECK(cudaHostRegister(ptr, size, cudaHostRegisterDefault));
+  return flagcxSuccess;
 }
-flagcxResult_t kunlunAdaptorHostUnregister(void *) {
-  return flagcxNotSupported;
+flagcxResult_t kunlunAdaptorHostUnregister(void *ptr) {
+  if (ptr == NULL) {
+    return flagcxInvalidArgument;
+  }
+  DEVCHECK(cudaHostUnregister(ptr));
+  return flagcxSuccess;
 }
 
 // Symmetric memory VMM stubs (not supported)

flagcx/flagcx.cc

@@ -84,7 +84,7 @@ static struct flagcxDeviceHandle globalDeviceHandle {
       // Event functions
       deviceAdaptor->eventCreate, deviceAdaptor->eventDestroy,
       deviceAdaptor->eventRecord, deviceAdaptor->eventSynchronize,
-      deviceAdaptor->eventQuery,
+      deviceAdaptor->eventQuery, deviceAdaptor->eventElapsedTime,
       // IpcMemHandle functions
       deviceAdaptor->ipcMemHandleCreate, deviceAdaptor->ipcMemHandleGet,
       deviceAdaptor->ipcMemHandleOpen, deviceAdaptor->ipcMemHandleClose,
@@ -117,6 +117,7 @@ void flagcxRebuildGlobalDeviceHandle() {
   globalDeviceHandle.eventRecord = deviceAdaptor->eventRecord;
   globalDeviceHandle.eventSynchronize = deviceAdaptor->eventSynchronize;
   globalDeviceHandle.eventQuery = deviceAdaptor->eventQuery;
+  globalDeviceHandle.eventElapsedTime = deviceAdaptor->eventElapsedTime;
   // IpcMemHandle functions
   globalDeviceHandle.ipcMemHandleCreate = deviceAdaptor->ipcMemHandleCreate;
   globalDeviceHandle.ipcMemHandleGet = deviceAdaptor->ipcMemHandleGet;

flagcx/include/flagcx.h

@@ -172,6 +172,8 @@ struct flagcxDeviceHandle {
   flagcxResult_t (*eventRecord)(flagcxEvent_t event, flagcxStream_t stream);
   flagcxResult_t (*eventSynchronize)(flagcxEvent_t event);
   flagcxResult_t (*eventQuery)(flagcxEvent_t event);
+  flagcxResult_t (*eventElapsedTime)(float *ms, flagcxEvent_t start,
+                                     flagcxEvent_t end);
   // IpcMemHandle functions
   flagcxResult_t (*ipcMemHandleCreate)(flagcxIpcMemHandle_t *handle,
                                        size_t *size);

plugin/interservice/flagcx_wrapper.py

@@ -93,6 +93,8 @@ class flagcxUniqueId(ctypes.Structure):
 EVENT_RECORD_FUNCTYPE = ctypes.CFUNCTYPE(flagcxResult_t, flagcxEvent_t, flagcxStream_t)
 EVENT_SYNCHRONIZE_FUNCTYPE = ctypes.CFUNCTYPE(flagcxResult_t, flagcxEvent_t)
 EVENT_QUERY_FUNCTYPE = ctypes.CFUNCTYPE(flagcxResult_t, flagcxEvent_t)
+EVENT_ELAPSED_TIME_FUNCTYPE = ctypes.CFUNCTYPE(
+    flagcxResult_t, ctypes.POINTER(ctypes.c_float), flagcxEvent_t, flagcxEvent_t)
 
 IPC_MEM_HANDLE_CREATE_FUNCTYPE = ctypes.CFUNCTYPE(flagcxResult_t, ctypes.POINTER(flagcxIpcMemHandle_t), ctypes.POINTER(ctypes.c_size_t))
 IPC_MEM_HANDLE_GET_FUNCTYPE = ctypes.CFUNCTYPE(flagcxResult_t, flagcxIpcMemHandle_t, ctypes.c_void_p)
@@ -127,6 +129,7 @@ class flagcxDeviceHandle(ctypes.Structure):
         ("eventRecord", EVENT_RECORD_FUNCTYPE),
         ("eventSynchronize", EVENT_SYNCHRONIZE_FUNCTYPE),
         ("eventQuery", EVENT_QUERY_FUNCTYPE),
+        ("eventElapsedTime", EVENT_ELAPSED_TIME_FUNCTYPE),
         # IpcMemHandle functions
         ("ipcMemHandleCreate", IPC_MEM_HANDLE_CREATE_FUNCTYPE),
         ("ipcMemHandleGet", IPC_MEM_HANDLE_GET_FUNCTYPE),

test/unittest/adaptor/test_device_adaptor.cpp

@@ -446,3 +446,193 @@ int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }
+// Test: obtain the device-visible alias of mapped host memory.
+TEST_F(DeviceAdaptorTest, HostGetDevicePointer) {
+  ASSERT_NE(devHandle->hostGetDevicePointer, nullptr);
+  void *hostPtr = nullptr;
+  ASSERT_EQ(devHandle->deviceMalloc(&hostPtr, TEST_SIZE, flagcxMemHost, nullptr),
+            flagcxSuccess);
+  ASSERT_NE(hostPtr, nullptr);
+  void *devicePtr = nullptr;
+  EXPECT_EQ(devHandle->hostGetDevicePointer(&devicePtr, hostPtr), flagcxSuccess);
+  EXPECT_NE(devicePtr, nullptr);
+  EXPECT_EQ(devHandle->hostGetDevicePointer(nullptr, hostPtr),
+            flagcxInvalidArgument);
+  EXPECT_EQ(devHandle->hostGetDevicePointer(&devicePtr, nullptr),
+            flagcxInvalidArgument);
+  EXPECT_EQ(devHandle->deviceFree(hostPtr, flagcxMemHost, nullptr),
+            flagcxSuccess);
+}
+
+// Test: Host memory register / get device pointer / unregister
+// flagcxDeviceHandle does not expose hostRegister/hostUnregister, so we
+// access them through the internal deviceAdaptor pointer (from adaptor.h).
+// Portable across all backends: skips if not implemented (NULL or NotSupported).
+TEST_F(DeviceAdaptorTest, HostRegisterUnregister) {
+  if (!deviceAdaptor->hostRegister || !deviceAdaptor->hostUnregister) {
+    GTEST_SKIP() << "hostRegister/hostUnregister not implemented";
+  }
+
+  const size_t sz = 4096;
+  void *hostPtr = malloc(sz);
+  ASSERT_NE(hostPtr, nullptr);
+
+  // Register host memory as pinned (page-locked) memory.
+  auto result = deviceAdaptor->hostRegister(hostPtr, sz);
+  if (result == flagcxNotSupported) {
+    free(hostPtr);
+    GTEST_SKIP() << "hostRegister not supported on this backend";
+  }
+  EXPECT_EQ(result, flagcxSuccess);
+
+  if (result == flagcxSuccess) {
+    // Unregister
+    auto r2 = deviceAdaptor->hostUnregister(hostPtr);
+    EXPECT_EQ(r2, flagcxSuccess);
+  }
+  free(hostPtr);
+
+  // Verify invalid arguments are rejected (only if backend has real impl)
+  auto nullResult = deviceAdaptor->hostRegister(NULL, sz);
+  if (nullResult != flagcxNotSupported) {
+    EXPECT_EQ(nullResult, flagcxInvalidArgument);
+  }
+  auto zeroResult = deviceAdaptor->hostRegister(hostPtr, 0);
+  if (zeroResult != flagcxNotSupported) {
+    EXPECT_EQ(zeroResult, flagcxInvalidArgument);
+  }
+  auto unregNullResult = deviceAdaptor->hostUnregister(NULL);
+  if (unregNullResult != flagcxNotSupported) {
+    EXPECT_EQ(unregNullResult, flagcxInvalidArgument);
+  }
+}
+
+// Test: getDevicePciBusId — string format and invalid-arg guards
+TEST_F(DeviceAdaptorTest, GetDevicePciBusId) {
+  int numDevices = 0;
+  ASSERT_EQ(devHandle->getDeviceCount(&numDevices), flagcxSuccess);
+  ASSERT_GT(numDevices, 0);
+
+  for (int dev = 0; dev < numDevices; dev++) {
+    char pciBusId[FLAGCX_DEVICE_PCI_BUSID_BUFFER_SIZE] = {};
+    ASSERT_EQ(deviceAdaptor->getDevicePciBusId(pciBusId, sizeof(pciBusId), dev),
+              flagcxSuccess)
+        << "getDevicePciBusId failed for device " << dev;
+    EXPECT_NE(pciBusId[0], '\0') << "empty PCI bus ID for device " << dev;
+
+    // Verify format: domain:bus:device.function (4 hex fields)
+    unsigned int domain = 0, bus = 0, pciDevice = 0, function = 0;
+    EXPECT_EQ(sscanf(pciBusId, "%x:%x:%x.%x", &domain, &bus, &pciDevice, &function),
+              4)
+        << "unexpected PCI bus ID format: " << pciBusId;
+
+    std::cout << "Device " << dev << ": pci=" << pciBusId << std::endl;
+  }
+
+  // Invalid-argument guards
+  char buf[FLAGCX_DEVICE_PCI_BUSID_BUFFER_SIZE] = {};
+  EXPECT_EQ(deviceAdaptor->getDevicePciBusId(nullptr, sizeof(buf), 0),
+            flagcxInvalidArgument);
+
+  // Out-of-range device index
+  EXPECT_NE(deviceAdaptor->getDevicePciBusId(buf, sizeof(buf), -1), flagcxSuccess);
+  EXPECT_NE(deviceAdaptor->getDevicePciBusId(buf, sizeof(buf), numDevices),
+            flagcxSuccess);
+}
+
+// Test: getDeviceProperties — name and PCI fields, invalid-arg guards
+TEST_F(DeviceAdaptorTest, GetDeviceProperties) {
+  int numDevices = 0;
+  ASSERT_EQ(devHandle->getDeviceCount(&numDevices), flagcxSuccess);
+  ASSERT_GT(numDevices, 0);
+
+  for (int dev = 0; dev < numDevices; dev++) {
+    flagcxDevProps props = {};
+    ASSERT_EQ(deviceAdaptor->getDeviceProperties(&props, dev), flagcxSuccess)
+        << "getDeviceProperties failed for device " << dev;
+    EXPECT_NE(props.name[0], '\0') << "empty device name for device " << dev;
+
+    // PCI fields are parsed from cudaDeviceGetPCIBusId string
+    EXPECT_GE(props.pciBusId,    0) << "pciBusId out of range for device " << dev;
+    EXPECT_LE(props.pciBusId,  255) << "pciBusId out of range for device " << dev;
+    EXPECT_GE(props.pciDeviceId, 0) << "pciDeviceId out of range for device " << dev;
+    EXPECT_LE(props.pciDeviceId, 31) << "pciDeviceId out of range for device " << dev;
+    EXPECT_GE(props.pciDomainId, 0) << "pciDomainId out of range for device " << dev;
+    EXPECT_LE(props.pciDomainId, 65535) << "pciDomainId out of range for device " << dev;
+
+    std::cout << "Device " << dev << ": name=" << props.name
+              << ", pciBusId=" << props.pciBusId
+              << ", pciDeviceId=" << props.pciDeviceId
+              << ", pciDomainId=" << props.pciDomainId << std::endl;
+  }
+
+  // Invalid-argument guards
+  EXPECT_EQ(deviceAdaptor->getDeviceProperties(nullptr, 0),
+            flagcxInvalidArgument);
+
+  // Out-of-range device index
+  flagcxDevProps props = {};
+  EXPECT_NE(deviceAdaptor->getDeviceProperties(&props, -1), flagcxSuccess);
+  EXPECT_NE(deviceAdaptor->getDeviceProperties(&props, numDevices),
+            flagcxSuccess);
+}
+
+// Test: getDeviceByPciBusId — reverse lookup and invalid-arg guards
+TEST_F(DeviceAdaptorTest, GetDeviceByPciBusId) {
+  int numDevices = 0;
+  ASSERT_EQ(devHandle->getDeviceCount(&numDevices), flagcxSuccess);
+  ASSERT_GT(numDevices, 0);
+
+  for (int dev = 0; dev < numDevices; dev++) {
+    // Get PCI bus ID string directly from runtime (independent of getDevicePciBusId)
+    char pciBusId[FLAGCX_DEVICE_PCI_BUSID_BUFFER_SIZE] = {};
+    ASSERT_EQ(cudaDeviceGetPCIBusId(pciBusId, sizeof(pciBusId), dev), cudaSuccess)
+        << "cudaDeviceGetPCIBusId failed for dev=" << dev;
+
+    // Reverse lookup: string -> device index
+    int result = -1;
+    ASSERT_EQ(deviceAdaptor->getDeviceByPciBusId(&result, pciBusId), flagcxSuccess)
+        << "getDeviceByPciBusId failed for pci=" << pciBusId;
+    EXPECT_EQ(result, dev)
+        << "round-trip mismatch: pci=" << pciBusId
+        << " returned dev=" << result << " expected=" << dev;
+
+    std::cout << "Device " << dev << ": pci=" << pciBusId
+              << " -> dev=" << result << std::endl;
+  }
+
+  // Invalid-argument guards
+  int dev = -1;
+  char pciBusId[FLAGCX_DEVICE_PCI_BUSID_BUFFER_SIZE] = {};
+  EXPECT_EQ(deviceAdaptor->getDeviceByPciBusId(nullptr, pciBusId),
+            flagcxInvalidArgument);
+  EXPECT_EQ(deviceAdaptor->getDeviceByPciBusId(&dev, nullptr),
+            flagcxInvalidArgument);
+
+  // Invalid PCI string
+  EXPECT_NE(deviceAdaptor->getDeviceByPciBusId(&dev, "invalid"), flagcxSuccess);
+}
+
+// Test: eventElapsedTime reports the duration between two timing events.
+TEST_F(DeviceAdaptorTest, EventElapsedTime) {
+  ASSERT_NE(devHandle->eventElapsedTime, nullptr);
+  flagcxEvent_t startEvent = nullptr;
+  flagcxEvent_t endEvent = nullptr;
+  ASSERT_EQ(devHandle->eventCreate(&startEvent, flagcxEventDefault), flagcxSuccess);
+  ASSERT_EQ(devHandle->eventCreate(&endEvent, flagcxEventDefault), flagcxSuccess);
+  ASSERT_EQ(devHandle->eventRecord(startEvent, stream), flagcxSuccess);
+  ASSERT_EQ(devHandle->eventRecord(endEvent, stream), flagcxSuccess);
+  ASSERT_EQ(devHandle->eventSynchronize(endEvent), flagcxSuccess);
+  float elapsedMs = -1.0f;
+  EXPECT_EQ(devHandle->eventElapsedTime(&elapsedMs, startEvent, endEvent),
+            flagcxSuccess);
+  EXPECT_GE(elapsedMs, 0.0f);
+  EXPECT_EQ(devHandle->eventElapsedTime(nullptr, startEvent, endEvent),
+            flagcxInvalidArgument);
+  EXPECT_EQ(devHandle->eventElapsedTime(&elapsedMs, nullptr, endEvent),
+            flagcxInvalidArgument);
+  EXPECT_EQ(devHandle->eventElapsedTime(&elapsedMs, startEvent, nullptr),
+            flagcxInvalidArgument);
+  EXPECT_EQ(devHandle->eventDestroy(startEvent), flagcxSuccess);
+  EXPECT_EQ(devHandle->eventDestroy(endEvent), flagcxSuccess);
+}