RE: [PATCH v3 1/2] dma-mapping: add benchmark support for streaming DMA APIs

Hello Robin, Christoph, Any further comment? John suggested that "depends on DEBUG_FS" should be added in Kconfig. I am collecting more comments to send v4 together with fixing this minor issue :-)

Thanks Barry

-----Original Message----- From: Song Bao Hua (Barry Song) Sent: Monday, November 2, 2020 9:07 PM To: iommu@lists.linux-foundation.org; hch@lst.de; robin.murphy@arm.com; m.szyprowski@samsung.com Cc: Linuxarm linuxarm@huawei.com; linux-kselftest@vger.kernel.org; xuwei (O) xuwei5@huawei.com; Song Bao Hua (Barry Song) song.bao.hua@hisilicon.com; Joerg Roedel joro@8bytes.org; Will Deacon will@kernel.org; Shuah Khan shuah@kernel.org Subject: [PATCH v3 1/2] dma-mapping: add benchmark support for streaming DMA APIs

Nowadays, there are increasing requirements to benchmark the performance of dma_map and dma_unmap particually while the device is attached to an IOMMU.

This patch enables the support. Users can run specified number of threads to do dma_map_page and dma_unmap_page on a specific NUMA node with the specified duration. Then dma_map_benchmark will calculate the average latency for map and unmap.

A difficulity for this benchmark is that dma_map/unmap APIs must run on a particular device. Each device might have different backend of IOMMU or non-IOMMU.

So we use the driver_override to bind dma_map_benchmark to a particual device by: For platform devices: echo dma_map_benchmark > /sys/bus/platform/devices/xxx/driver_override echo xxx > /sys/bus/platform/drivers/xxx/unbind echo xxx > /sys/bus/platform/drivers/dma_map_benchmark/bind

For PCI devices: echo dma_map_benchmark > /sys/bus/pci/devices/0000:00:01.0/driver_override echo 0000:00:01.0 > /sys/bus/pci/drivers/xxx/unbind echo 0000:00:01.0 > /sys/bus/pci/drivers/dma_map_benchmark/bind

Cc: Joerg Roedel joro@8bytes.org Cc: Will Deacon will@kernel.org Cc: Shuah Khan shuah@kernel.org Cc: Christoph Hellwig hch@lst.de Cc: Marek Szyprowski m.szyprowski@samsung.com Cc: Robin Murphy robin.murphy@arm.com Signed-off-by: Barry Song song.bao.hua@hisilicon.com

---

-v3:

• fix build issues reported by 0day kernel test robot

-v2:

• add PCI support; v1 supported platform devices only
• replace ssleep by msleep_interruptible() to permit users to exit benchmark before it is completed
• many changes according to Robin's suggestions, thanks! Robin
  • add standard deviation output to reflect the worst case
  • check users' parameters strictly like the number of threads
  • make cache dirty before dma_map
  • fix unpaired dma_map_page and dma_unmap_single;
  • remove redundant "long long" before ktime_to_ns();
  • use devm_add_action()

kernel/dma/Kconfig | 8 + kernel/dma/Makefile | 1 + kernel/dma/map_benchmark.c | 296 +++++++++++++++++++++++++++++++++++++ 3 files changed, 305 insertions(+) create mode 100644 kernel/dma/map_benchmark.c

diff --git a/kernel/dma/Kconfig b/kernel/dma/Kconfig index c99de4a21458..949c53da5991 100644 --- a/kernel/dma/Kconfig +++ b/kernel/dma/Kconfig @@ -225,3 +225,11 @@ config DMA_API_DEBUG_SG is technically out-of-spec.

 If unsure, say N.

+config DMA_MAP_BENCHMARK

• bool "Enable benchmarking of streaming DMA mapping"
• help

•  Provides /sys/kernel/debug/dma_map_benchmark that helps with
  

testing

•  performance of dma_(un)map_page.
  

•  See tools/testing/selftests/dma/dma_map_benchmark.c
  

diff --git a/kernel/dma/Makefile b/kernel/dma/Makefile index dc755ab68aab..7aa6b26b1348 100644 --- a/kernel/dma/Makefile +++ b/kernel/dma/Makefile @@ -10,3 +10,4 @@ obj-$(CONFIG_DMA_API_DEBUG) += debug.o obj-$(CONFIG_SWIOTLB) += swiotlb.o obj-$(CONFIG_DMA_COHERENT_POOL) += pool.o obj-$(CONFIG_DMA_REMAP) += remap.o +obj-$(CONFIG_DMA_MAP_BENCHMARK) += map_benchmark.o diff --git a/kernel/dma/map_benchmark.c b/kernel/dma/map_benchmark.c new file mode 100644 index 000000000000..dc4e5ff48a2d --- /dev/null +++ b/kernel/dma/map_benchmark.c @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: GPL-2.0-only +/*

• • Copyright (C) 2020 Hisilicon Limited.
• */

+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

+#include <linux/debugfs.h> +#include <linux/delay.h> +#include <linux/device.h> +#include <linux/dma-mapping.h> +#include <linux/kernel.h> +#include <linux/kthread.h> +#include <linux/math64.h> +#include <linux/module.h> +#include <linux/pci.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/timekeeping.h>

+#define DMA_MAP_BENCHMARK _IOWR('d', 1, struct map_benchmark) +#define DMA_MAP_MAX_THREADS 1024 +#define DMA_MAP_MAX_SECONDS 300

+struct map_benchmark {

• __u64 avg_map_100ns; /* average map latency in 100ns */
• __u64 map_stddev; /* standard deviation of map latency */
• __u64 avg_unmap_100ns; /* as above */
• __u64 unmap_stddev;
• __u32 threads; /* how many threads will do map/unmap in parallel */
• __u32 seconds; /* how long the test will last */
• int node; /* which numa node this benchmark will run on */
• __u64 expansion[10]; /* For future use */

+};

+struct map_benchmark_data {

• struct map_benchmark bparam;
• struct device *dev;
• struct dentry *debugfs;
• atomic64_t sum_map_100ns;
• atomic64_t sum_unmap_100ns;
• atomic64_t sum_square_map;
• atomic64_t sum_square_unmap;
• atomic64_t loops;

+};

+static int map_benchmark_thread(void *data) {

• void *buf;
• dma_addr_t dma_addr;
• struct map_benchmark_data *map = data;
• int ret = 0;
• buf = (void *)__get_free_page(GFP_KERNEL);
• if (!buf)

• return -ENOMEM;
  

• while (!kthread_should_stop()) {

• __u64 map_100ns, unmap_100ns, map_square, unmap_square;
  

• ktime_t map_stime, map_etime, unmap_stime, unmap_etime;
  

• /*
  

•  * for a non-coherent device, if we don't stain them in the cache,
  

•  * this will give an underestimate of the real-world overhead of
  

•  * BIDIRECTIONAL or TO_DEVICE mappings
  

•  * 66 means evertything goes well! 66 is lucky.
  

•  */
  

• memset(buf, 0x66, PAGE_SIZE);
  

• map_stime = ktime_get();
  

• dma_addr = dma_map_single(map->dev, buf, PAGE_SIZE,
  

DMA_BIDIRECTIONAL);

• if (unlikely(dma_mapping_error(map->dev, dma_addr))) {
  

• 	pr_err("dma_map_single failed on %s\n",
  

dev_name(map->dev));

• 	ret = -ENOMEM;
  

• 	goto out;
  

• }
  

• map_etime = ktime_get();
  

• unmap_stime = ktime_get();
  

• dma_unmap_single(map->dev, dma_addr, PAGE_SIZE,
  

DMA_BIDIRECTIONAL);

• unmap_etime = ktime_get();
  

• /* calculate sum and sum of squares */
  

• map_100ns = div64_ul(ktime_to_ns(ktime_sub(map_etime,
  

map_stime)), 100);

• unmap_100ns = div64_ul(ktime_to_ns(ktime_sub(unmap_etime,
  

unmap_stime)), 100);

• map_square = map_100ns * map_100ns;
  

• unmap_square = unmap_100ns * unmap_100ns;
  

• atomic64_add(map_100ns, &map->sum_map_100ns);
  

• atomic64_add(unmap_100ns, &map->sum_unmap_100ns);
  

• atomic64_add(map_square, &map->sum_square_map);
  

• atomic64_add(unmap_square, &map->sum_square_unmap);
  

• atomic64_inc(&map->loops);
  

• }

+out:

• free_page((unsigned long)buf);
• return ret;

+}

+static int do_map_benchmark(struct map_benchmark_data *map) {

• struct task_struct **tsk;
• int threads = map->bparam.threads;
• int node = map->bparam.node;
• const cpumask_t *cpu_mask = cpumask_of_node(node);
• __u64 loops;
• int ret = 0;
• int i;
• tsk = kmalloc_array(threads, sizeof(tsk), GFP_KERNEL);
• if (!tsk)

• return -ENOMEM;
  

• get_device(map->dev);
• for (i = 0; i < threads; i++) {

• tsk[i] = kthread_create_on_node(map_benchmark_thread, map,
  

• 		map->bparam.node, "dma-map-benchmark/%d", i);
  

• if (IS_ERR(tsk[i])) {
  

• 	pr_err("create dma_map thread failed\n");
  

• 	ret = PTR_ERR(tsk[i]);
  

• 	goto out;
  

• }
  

• if (node != NUMA_NO_NODE && node_online(node))
  

• 	kthread_bind_mask(tsk[i], cpu_mask);
  

• }
• /* clear the old value in the previous benchmark */
• atomic64_set(&map->sum_map_100ns, 0);
• atomic64_set(&map->sum_unmap_100ns, 0);
• atomic64_set(&map->sum_square_map, 0);
• atomic64_set(&map->sum_square_unmap, 0);
• atomic64_set(&map->loops, 0);
• for (i = 0; i < threads; i++)

• wake_up_process(tsk[i]);
  

• msleep_interruptible(map->bparam.seconds * 1000);
• /* wait for the completion of benchmark threads */
• for (i = 0; i < threads; i++) {

• ret = kthread_stop(tsk[i]);
  

• if (ret)
  

• 	goto out;
  

• }
• loops = atomic64_read(&map->loops);
• if (likely(loops > 0)) {

• __u64 map_variance, unmap_variance;
  

• /* average latency */
  

• map->bparam.avg_map_100ns =
  

div64_u64(atomic64_read(&map->sum_map_100ns), loops);

• map->bparam.avg_unmap_100ns =
  

+div64_u64(atomic64_read(&map->sum_unmap_100ns), loops);

• /* standard deviation of latency */
  

• map_variance =
  

div64_u64(atomic64_read(&map->sum_square_map), loops) -

• 	map->bparam.avg_map_100ns *
  

map->bparam.avg_map_100ns;

• unmap_variance =
  

div64_u64(atomic64_read(&map->sum_square_unmap), loops) -

• 	map->bparam.avg_unmap_100ns *
  

map->bparam.avg_unmap_100ns;

• map->bparam.map_stddev = int_sqrt64(map_variance);
  

• map->bparam.unmap_stddev = int_sqrt64(unmap_variance);
  

• }

+out:

• put_device(map->dev);
• kfree(tsk);
• return ret;

+}

+static long map_benchmark_ioctl(struct file *filep, unsigned int cmd,

• unsigned long arg)
  

+{

• struct map_benchmark_data *map = filep->private_data;
• int ret;
• if (copy_from_user(&map->bparam, (void __user *)arg,

sizeof(map->bparam)))

• return -EFAULT;
  

• switch (cmd) {
• case DMA_MAP_BENCHMARK:

• if (map->bparam.threads == 0 || map->bparam.threads >
  

DMA_MAP_MAX_THREADS) {

• 	pr_err("invalid thread number\n");
  

• 	return -EINVAL;
  

• }
  

• if (map->bparam.seconds == 0 || map->bparam.seconds >
  

DMA_MAP_MAX_SECONDS) {

• 	pr_err("invalid duration seconds\n");
  

• 	return -EINVAL;
  

• }
  

• ret = do_map_benchmark(map);
  

• break;
  

• default:

• return -EINVAL;
  

• }
• if (copy_to_user((void __user *)arg, &map->bparam,

sizeof(map->bparam)))

• return -EFAULT;
  

• return ret;

+}

+static const struct file_operations map_benchmark_fops = {

• .open = simple_open,
• .unlocked_ioctl = map_benchmark_ioctl, };

+static void map_benchmark_remove_debugfs(void *data) {

• struct map_benchmark_data *map = (struct map_benchmark_data *)data;
• debugfs_remove(map->debugfs);

+}

+static int __map_benchmark_probe(struct device *dev) {

• struct dentry *entry;
• struct map_benchmark_data *map;
• int ret;
• map = devm_kzalloc(dev, sizeof(*map), GFP_KERNEL);
• if (!map)

• return -ENOMEM;
  

• map->dev = dev;
• ret = devm_add_action(dev, map_benchmark_remove_debugfs, map);
• if (ret) {

• pr_err("Can't add debugfs remove action\n");
  

• return ret;
  

• }
• /*

• * we only permit a device bound with this driver, 2nd probe
  

• * will fail
  

• */
  

• entry = debugfs_create_file("dma_map_benchmark", 0600, NULL, map,

• 	&map_benchmark_fops);
  

• if (IS_ERR(entry))

• return PTR_ERR(entry);
  

• map->debugfs = entry;
• return 0;

+}

+static int map_benchmark_platform_probe(struct platform_device *pdev) {

• return __map_benchmark_probe(&pdev->dev);

+}

+static struct platform_driver map_benchmark_platform_driver = {

• .driver = {

• .name	= "dma_map_benchmark",
  

• },
• .probe = map_benchmark_platform_probe, };

+static int map_benchmark_pci_probe(struct pci_dev *pdev, const struct +pci_device_id *id) {

• return __map_benchmark_probe(&pdev->dev);

+}

+static struct pci_driver map_benchmark_pci_driver = {

• .name = "dma_map_benchmark",
• .probe = map_benchmark_pci_probe,

+};

+static int __init map_benchmark_init(void) {

• int ret;
• ret = pci_register_driver(&map_benchmark_pci_driver);
• if (ret)

• return ret;
  

• ret = platform_driver_register(&map_benchmark_platform_driver);
• if (ret) {

• pci_unregister_driver(&map_benchmark_pci_driver);
  

• return ret;
  

• }
• return 0;

+}

+static void __exit map_benchmark_cleanup(void) {

• platform_driver_unregister(&map_benchmark_platform_driver);
• pci_unregister_driver(&map_benchmark_pci_driver);

+}

+module_init(map_benchmark_init); +module_exit(map_benchmark_cleanup);

+MODULE_AUTHOR("Barry Song song.bao.hua@hisilicon.com"); +MODULE_DESCRIPTION("dma_map benchmark driver"); MODULE_LICENSE("GPL"); -- 2.25.1