Commit 76793257 authored by Barry Song's avatar Barry Song Committed by Christoph Hellwig
Browse files

selftests/dma: add test application for DMA_MAP_BENCHMARK 



This patch provides the test application for DMA_MAP_BENCHMARK.

Before running the test application, we need to bind a device to dma_map_
benchmark driver. For example, unbind "xxx" from its original driver and
bind to dma_map_benchmark:

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

Another example 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

The below command will run 16 threads on numa node 0 for 10 seconds on
the device bound to dma_map_benchmark platform_driver or pci_driver:
./dma_map_benchmark -t 16 -s 10 -n 0
dma mapping benchmark: threads:16 seconds:10
average map latency(us):1.1 standard deviation:1.9
average unmap latency(us):0.5 standard deviation:0.8

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: default avatarBarry Song <song.bao.hua@hisilicon.com>
Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
parent 65789daa

MAINTAINERS

+6 −0
Original line number Diff line number Diff line
@@ -5237,6 +5237,12 @@ F: include/linux/dma-mapping.h 
F:	include/linux/dma-map-ops.h

F:	kernel/dma/









DMA MAPPING BENCHMARK









M:	Barry Song <song.bao.hua@hisilicon.com>









L:	iommu@lists.linux-foundation.org









F:	kernel/dma/map_benchmark.c









F:	tools/testing/selftests/dma/

















DMA-BUF HEAPS FRAMEWORK









M:	Sumit Semwal <sumit.semwal@linaro.org>









R:	Benjamin Gaignard <benjamin.gaignard@linaro.org>
































tools/testing/selftests/dma/Makefile
0 → 100644



+6
−0






























Original line number
Diff line number
Diff line









# SPDX-License-Identifier: GPL-2.0









CFLAGS += -I../../../../usr/include/



















TEST_GEN_PROGS := dma_map_benchmark



















include ../lib.mk
























tools/testing/selftests/dma/config
0 → 100644



+1
−0






























Original line number
Diff line number
Diff line









CONFIG_DMA_MAP_BENCHMARK=y
























tools/testing/selftests/dma/dma_map_benchmark.c
0 → 100644



+123
−0






























Original line number
Diff line number
Diff line









// SPDX-License-Identifier: GPL-2.0-only









/*









 * Copyright (C) 2020 Hisilicon Limited.









 */



















#include <fcntl.h>









#include <stdio.h>









#include <stdlib.h>









#include <unistd.h>









#include <sys/ioctl.h>









#include <sys/mman.h>









#include <linux/types.h>



















#define DMA_MAP_BENCHMARK	_IOWR('d', 1, struct map_benchmark)









#define DMA_MAP_MAX_THREADS	1024









#define DMA_MAP_MAX_SECONDS     300



















#define DMA_MAP_BIDIRECTIONAL	0









#define DMA_MAP_TO_DEVICE	1









#define DMA_MAP_FROM_DEVICE	2



















static char *directions[] = {









	"BIDIRECTIONAL",









	"TO_DEVICE",









	"FROM_DEVICE",









};



















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 */









	__s32 node; /* which numa node this benchmark will run on */









	__u32 dma_bits; /* DMA addressing capability */









	__u32 dma_dir; /* DMA data direction */









	__u64 expansion[10];	/* For future use */









};



















int main(int argc, char **argv)









{









	struct map_benchmark map;









	int fd, opt;









	/* default single thread, run 20 seconds on NUMA_NO_NODE */









	int threads = 1, seconds = 20, node = -1;









	/* default dma mask 32bit, bidirectional DMA */









	int bits = 32, dir = DMA_MAP_BIDIRECTIONAL;



















	int cmd = DMA_MAP_BENCHMARK;









	char *p;



















	while ((opt = getopt(argc, argv, "t:s:n:b:d:")) != -1) {









		switch (opt) {









		case 't':









			threads = atoi(optarg);









			break;









		case 's':









			seconds = atoi(optarg);









			break;









		case 'n':









			node = atoi(optarg);









			break;









		case 'b':









			bits = atoi(optarg);









			break;









		case 'd':









			dir = atoi(optarg);









			break;









		default:









			return -1;









		}









	}



















	if (threads <= 0 || threads > DMA_MAP_MAX_THREADS) {









		fprintf(stderr, "invalid number of threads, must be in 1-%d\n",









			DMA_MAP_MAX_THREADS);









		exit(1);









	}



















	if (seconds <= 0 || seconds > DMA_MAP_MAX_SECONDS) {









		fprintf(stderr, "invalid number of seconds, must be in 1-%d\n",









			DMA_MAP_MAX_SECONDS);









		exit(1);









	}



















	/* suppose the mininum DMA zone is 1MB in the world */









	if (bits < 20 || bits > 64) {









		fprintf(stderr, "invalid dma mask bit, must be in 20-64\n");









		exit(1);









	}



















	if (dir != DMA_MAP_BIDIRECTIONAL && dir != DMA_MAP_TO_DEVICE &&









			dir != DMA_MAP_FROM_DEVICE) {









		fprintf(stderr, "invalid dma direction\n");









		exit(1);









	}



















	fd = open("/sys/kernel/debug/dma_map_benchmark", O_RDWR);









	if (fd == -1) {









		perror("open");









		exit(1);









	}



















	map.seconds = seconds;









	map.threads = threads;









	map.node = node;









	map.dma_bits = bits;









	map.dma_dir = dir;









	if (ioctl(fd, cmd, &map)) {









		perror("ioctl");









		exit(1);









	}



















	printf("dma mapping benchmark: threads:%d seconds:%d node:%d dir:%s\n",









			threads, seconds, node, dir[directions]);









	printf("average map latency(us):%.1f standard deviation:%.1f\n",









			map.avg_map_100ns/10.0, map.map_stddev/10.0);









	printf("average unmap latency(us):%.1f standard deviation:%.1f\n",









			map.avg_unmap_100ns/10.0, map.unmap_stddev/10.0);



















	return 0;









}


























































CRA Git | Maintained and supported by SUSTech CRA and CCSE