[v4,1/2] gpudev: expose GPU memory to CPU
Checks
Commit Message
From: Elena Agostini <eagostini@nvidia.com>
Enable the possibility to expose a GPU memory area and make it
accessible from the CPU.
GPU memory has to be allocated via rte_gpu_mem_alloc().
This patch allows the gpudev library to map (and unmap),
through the GPU driver, a chunk of GPU memory and to return
a memory pointer usable by the CPU to access the GPU memory area.
Signed-off-by: Elena Agostini <eagostini@nvidia.com>
---
doc/guides/prog_guide/gpudev.rst | 9 +++++
drivers/gpu/cuda/cuda.c | 2 ++
lib/gpudev/gpudev.c | 61 ++++++++++++++++++++++++++++++++
lib/gpudev/gpudev_driver.h | 6 ++++
lib/gpudev/rte_gpudev.h | 49 +++++++++++++++++++++++++
lib/gpudev/version.map | 2 ++
6 files changed, 129 insertions(+)
Comments
> -----Original Message-----
> From: eagostini@nvidia.com <eagostini@nvidia.com>
> Sent: Thursday, January 27, 2022 11:47
> To: dev@dpdk.org
> Cc: Elena Agostini <eagostini@nvidia.com>
> Subject: [PATCH v4 1/2] gpudev: expose GPU memory to CPU
>
> From: Elena Agostini <eagostini@nvidia.com>
>
> Enable the possibility to expose a GPU memory area and make it
> accessible from the CPU.
>
> GPU memory has to be allocated via rte_gpu_mem_alloc().
>
> This patch allows the gpudev library to map (and unmap),
> through the GPU driver, a chunk of GPU memory and to return
> a memory pointer usable by the CPU to access the GPU memory area.
>
> Signed-off-by: Elena Agostini <eagostini@nvidia.com>
> ---
> doc/guides/prog_guide/gpudev.rst | 9 +++++
> drivers/gpu/cuda/cuda.c | 2 ++
> lib/gpudev/gpudev.c | 61 ++++++++++++++++++++++++++++++++
> lib/gpudev/gpudev_driver.h | 6 ++++
> lib/gpudev/rte_gpudev.h | 49 +++++++++++++++++++++++++
> lib/gpudev/version.map | 2 ++
> 6 files changed, 129 insertions(+)
>
> +__rte_experimental
> +void *rte_gpu_mem_cpu_map(int16_t dev_id, size_t size, void *ptr);
How about add some direction words like "to/from" to make it straightforward ?
For this: rte_gpu_mem_map_to_cpu ?
> +__rte_experimental
> +int rte_gpu_mem_cpu_unmap(int16_t dev_id, void *ptr);
> +
And rte_gpu_mem_unmap_to_cpu ?
> };
> --
> 2.17.1
> From: Wang, Haiyue <haiyue.wang@intel.com>
> Date: Thursday, 27 January 2022 at 07:56
> To: Elena Agostini <eagostini@nvidia.com>, dev@dpdk.org <dev@dpdk.org>
> Subject: RE: [PATCH v4 1/2] gpudev: expose GPU memory to CPU
> External email: Use caution opening links or attachments
>
>
> > -----Original Message-----
> > From: eagostini@nvidia.com <eagostini@nvidia.com>
> > Sent: Thursday, January 27, 2022 11:47
> > To: dev@dpdk.org
> > Cc: Elena Agostini <eagostini@nvidia.com>
> > Subject: [PATCH v4 1/2] gpudev: expose GPU memory to CPU
> >
> > From: Elena Agostini <eagostini@nvidia.com>
> >
> > Enable the possibility to expose a GPU memory area and make it
> > accessible from the CPU.
> >
> > GPU memory has to be allocated via rte_gpu_mem_alloc().
> >
> > This patch allows the gpudev library to map (and unmap),
> > through the GPU driver, a chunk of GPU memory and to return
> > a memory pointer usable by the CPU to access the GPU memory area.
> >
> > Signed-off-by: Elena Agostini <eagostini@nvidia.com>
> > ---
> > doc/guides/prog_guide/gpudev.rst | 9 +++++
> > drivers/gpu/cuda/cuda.c | 2 ++
> > lib/gpudev/gpudev.c | 61 ++++++++++++++++++++++++++++++++
> > lib/gpudev/gpudev_driver.h | 6 ++++
> > lib/gpudev/rte_gpudev.h | 49 +++++++++++++++++++++++++
> > lib/gpudev/version.map | 2 ++
> > 6 files changed, 129 insertions(+)
> >
>
>
> > +__rte_experimental
> > +void *rte_gpu_mem_cpu_map(int16_t dev_id, size_t size, void *ptr);
>
> How about add some direction words like "to/from" to make it straightforward ?
>
> For this: rte_gpu_mem_map_to_cpu ?
>
> > +__rte_experimental
> > +int rte_gpu_mem_cpu_unmap(int16_t dev_id, void *ptr);
> > +
>
> And rte_gpu_mem_unmap_to_cpu ?
>
> > };
> > --
> > 2.17.1
Motivation behind the name is to be compliant with
rte_*_dma_map/unmap() functions where the entity comes first
(DMA) and the action later (map/unmap).
I think your proposal is more readable but it's also too
verbose for an API (map_to_cpu/unmap_from_cpu).
From: Elena Agostini <eagostini@nvidia.com>
Sent: Thursday, February 10, 2022 18:38
To: Wang, Haiyue <haiyue.wang@intel.com>; dev@dpdk.org
Subject: Re: [PATCH v4 1/2] gpudev: expose GPU memory to CPU
> From: Wang, Haiyue <mailto:haiyue.wang@intel.com>
> Date: Thursday, 27 January 2022 at 07:56
> To: Elena Agostini <mailto:eagostini@nvidia.com>, mailto:dev@dpdk.org <mailto:dev@dpdk.org>
> Subject: RE: [PATCH v4 1/2] gpudev: expose GPU memory to CPU
> External email: Use caution opening links or attachments
>
>
> > -----Original Message-----
> > From: mailto:eagostini@nvidia.com <mailto:eagostini@nvidia.com>
> > Sent: Thursday, January 27, 2022 11:47
> > To: mailto:dev@dpdk.org
> > Cc: Elena Agostini <mailto:eagostini@nvidia.com>
> > Subject: [PATCH v4 1/2] gpudev: expose GPU memory to CPU
> >
> > From: Elena Agostini <mailto:eagostini@nvidia.com>
> >
> > Enable the possibility to expose a GPU memory area and make it
> > accessible from the CPU.
> >
> > GPU memory has to be allocated via rte_gpu_mem_alloc().
> >
> > This patch allows the gpudev library to map (and unmap),
> > through the GPU driver, a chunk of GPU memory and to return
> > a memory pointer usable by the CPU to access the GPU memory area.
> >
> > Signed-off-by: Elena Agostini <mailto:eagostini@nvidia.com>
> > ---
> > doc/guides/prog_guide/gpudev.rst | 9 +++++
> > drivers/gpu/cuda/cuda.c | 2 ++
> > lib/gpudev/gpudev.c | 61 ++++++++++++++++++++++++++++++++
> > lib/gpudev/gpudev_driver.h | 6 ++++
> > lib/gpudev/rte_gpudev.h | 49 +++++++++++++++++++++++++
> > lib/gpudev/version.map | 2 ++
> > 6 files changed, 129 insertions(+)
> >
>
>
> > +__rte_experimental
> > +void *rte_gpu_mem_cpu_map(int16_t dev_id, size_t size, void *ptr);
>
> How about add some direction words like "to/from" to make it straightforward ?
>
> For this: rte_gpu_mem_map_to_cpu ?
>
> > +__rte_experimental
> > +int rte_gpu_mem_cpu_unmap(int16_t dev_id, void *ptr);
> > +
>
> And rte_gpu_mem_unmap_to_cpu ?
>
> > };
> > --
> > 2.17.1
> Motivation behind the name is to be compliant with
> rte_*_dma_map/unmap() functions where the entity comes first
> (DMA) and the action later (map/unmap).
> I think your proposal is more readable but it's also too
> verbose for an API (map_to_cpu/unmap_from_cpu).
Then just ' rte_gpu_mem_map' & ' rte_gpu_mem_umap', since DPDK is running on CPU. ;-)
@@ -73,6 +73,15 @@ Later, it's also possible to unregister that memory with gpudev.
CPU memory registered outside of the gpudev library
(e.g. with GPU specific library) cannot be unregistered by the gpudev library.
+CPU mapping
+~~~~~~~~~~~~~~~~~~~
+
+gpudev can map into the CPU address space a GPU memory address allocated with gpudev.
+gpudev returns a pointer the CPU can use to access (ready or write) GPU memory.
+Later, it's also possible to unmap that memory with gpudev.
+GPU memory CPU mapped outside of the gpudev library (e.g. with GPU specific library)
+cannot be unmapped by the gpudev library.
+
Memory Barrier
~~~~~~~~~~~~~~
@@ -1177,6 +1177,8 @@ cuda_gpu_probe(__rte_unused struct rte_pci_driver *pci_drv, struct rte_pci_devic
dev->ops.mem_free = cuda_mem_free;
dev->ops.mem_register = cuda_mem_register;
dev->ops.mem_unregister = cuda_mem_unregister;
+ dev->ops.mem_cpu_map = NULL;
+ dev->ops.mem_cpu_unmap = NULL;
dev->ops.wmb = cuda_wmb;
rte_gpu_complete_new(dev);
@@ -640,6 +640,67 @@ rte_gpu_mem_unregister(int16_t dev_id, void *ptr)
return GPU_DRV_RET(dev->ops.mem_unregister(dev, ptr));
}
+void *
+rte_gpu_mem_cpu_map(int16_t dev_id, size_t size, void *ptr)
+{
+ struct rte_gpu *dev;
+ void *ptr_out;
+ int ret;
+
+ dev = gpu_get_by_id(dev_id);
+ if (dev == NULL) {
+ GPU_LOG(ERR, "mem CPU map for invalid device ID %d", dev_id);
+ rte_errno = ENODEV;
+ return NULL;
+ }
+
+ if (dev->ops.mem_cpu_map == NULL) {
+ GPU_LOG(ERR, "mem CPU map not supported");
+ rte_errno = ENOTSUP;
+ return NULL;
+ }
+
+ if (ptr == NULL || size == 0) /* dry-run */
+ return NULL;
+
+ ret = GPU_DRV_RET(dev->ops.mem_cpu_map(dev, size, ptr, &ptr_out));
+
+ switch (ret) {
+ case 0:
+ return ptr_out;
+ case -ENOMEM:
+ case -E2BIG:
+ rte_errno = -ret;
+ return NULL;
+ default:
+ rte_errno = -EPERM;
+ return NULL;
+ }
+}
+
+int
+rte_gpu_mem_cpu_unmap(int16_t dev_id, void *ptr)
+{
+ struct rte_gpu *dev;
+
+ dev = gpu_get_by_id(dev_id);
+ if (dev == NULL) {
+ GPU_LOG(ERR, "cpu_unmap mem for invalid device ID %d", dev_id);
+ rte_errno = ENODEV;
+ return -rte_errno;
+ }
+
+ if (dev->ops.mem_cpu_unmap == NULL) {
+ rte_errno = ENOTSUP;
+ return -rte_errno;
+ }
+
+ if (ptr == NULL) /* dry-run */
+ return 0;
+
+ return GPU_DRV_RET(dev->ops.mem_cpu_unmap(dev, ptr));
+}
+
int
rte_gpu_wmb(int16_t dev_id)
{
@@ -31,6 +31,8 @@ typedef int (rte_gpu_mem_alloc_t)(struct rte_gpu *dev, size_t size, unsigned int
typedef int (rte_gpu_mem_free_t)(struct rte_gpu *dev, void *ptr);
typedef int (rte_gpu_mem_register_t)(struct rte_gpu *dev, size_t size, void *ptr);
typedef int (rte_gpu_mem_unregister_t)(struct rte_gpu *dev, void *ptr);
+typedef int (rte_gpu_mem_cpu_map_t)(struct rte_gpu *dev, size_t size, void *ptr_in, void **ptr_out);
+typedef int (rte_gpu_mem_cpu_unmap_t)(struct rte_gpu *dev, void *ptr);
typedef int (rte_gpu_wmb_t)(struct rte_gpu *dev);
struct rte_gpu_ops {
@@ -46,6 +48,10 @@ struct rte_gpu_ops {
rte_gpu_mem_register_t *mem_register;
/* Unregister CPU memory from device. */
rte_gpu_mem_unregister_t *mem_unregister;
+ /* Map GPU memory for CPU visibility. */
+ rte_gpu_mem_cpu_map_t *mem_cpu_map;
+ /* Unmap GPU memory for CPU visibility. */
+ rte_gpu_mem_cpu_unmap_t *mem_cpu_unmap;
/* Enforce GPU write memory barrier. */
rte_gpu_wmb_t *wmb;
};
@@ -452,6 +452,55 @@ int rte_gpu_mem_register(int16_t dev_id, size_t size, void *ptr);
__rte_experimental
int rte_gpu_mem_unregister(int16_t dev_id, void *ptr);
+/**
+ * @warning
+ * @b EXPERIMENTAL: this API may change without prior notice.
+ *
+ * Map a chunk of GPU memory to make it accessible from the CPU
+ * using the memory pointer returned by the function.
+ * GPU memory has to be allocated via rte_gpu_mem_alloc().
+ *
+ * @param dev_id
+ * Device ID requiring mapped memory.
+ * @param size
+ * Number of bytes to map.
+ * Requesting 0 will do nothing.
+ * @param ptr
+ * Pointer to the GPU memory area to be mapped.
+ * NULL is a no-op accepted value.
+
+ * @return
+ * A pointer to the mapped GPU memory usable by the CPU, otherwise NULL and rte_errno is set:
+ * - ENODEV if invalid dev_id
+ * - ENOTSUP if operation not supported by the driver
+ * - E2BIG if size is higher than limit
+ * - ENOMEM if out of space
+ * - EPERM if driver error
+ */
+__rte_experimental
+void *rte_gpu_mem_cpu_map(int16_t dev_id, size_t size, void *ptr);
+
+/**
+ * @warning
+ * @b EXPERIMENTAL: this API may change without prior notice.
+ *
+ * Unmap a chunk of GPU memory previously mapped with rte_gpu_mem_cpu_map()
+ *
+ * @param dev_id
+ * Reference device ID.
+ * @param ptr
+ * Pointer to the memory area to be unmapped.
+ * NULL is a no-op accepted value.
+ *
+ * @return
+ * 0 on success, -rte_errno otherwise:
+ * - ENODEV if invalid dev_id
+ * - ENOTSUP if operation not supported by the driver
+ * - EPERM if driver error
+ */
+__rte_experimental
+int rte_gpu_mem_cpu_unmap(int16_t dev_id, void *ptr);
+
/**
* @warning
* @b EXPERIMENTAL: this API may change without prior notice.
@@ -20,8 +20,10 @@ EXPERIMENTAL {
rte_gpu_init;
rte_gpu_is_valid;
rte_gpu_mem_alloc;
+ rte_gpu_mem_cpu_map;
rte_gpu_mem_free;
rte_gpu_mem_register;
+ rte_gpu_mem_cpu_unmap;
rte_gpu_mem_unregister;
rte_gpu_wmb;
};