Merge pull request #320 from hc235280/support_ib_send_lat

Add support for DMA-buffers in Cambricon devices

Author: sshaulnv

configure.ac

@@ -447,6 +447,9 @@ AS_IF([test "x$enable_mlu" = xyes], [
                         [AC_MSG_ERROR([could not find cn_api.h in include path])])
        AC_SEARCH_LIBS([cnMalloc], [cndrv], [],
                       [AC_MSG_ERROR([could not find library, cndrv])])
+       AC_SEARCH_LIBS([cnMemGetHandleForAddressRange], [cndrv],
+					  [AC_DEFINE([HAVE_MLU_DMABUF], [1], [Enable MLU DMA buffers])],
+		      [])
        ])
 
 AM_CONDITIONAL([MLU], [test x$enable_mlu = xyes])

man/perftest.1

@@ -389,6 +389,14 @@ many different options and modes.
  Not relevant for raw_ethernet_fs_rate.
  System support required.
 .TP
+.B --use_mlu=<mlu device id>
+ Use MLU specific device for HW accelerator direct RDMA testing.
+ System support required.
+.TP
+.B --use_mlu_dmabuf
+ Use MLU DMA-BUF for HW accelerator direct RDMA testing.
+ System support required.
+.TP
 .B --use_opencl=<opencl device id>
  Use OpenCl specific device for GPUDirect RDMA testing
  Not relevant for raw_ethernet_fs_rate.

src/mlu_memory.c

@@ -43,7 +43,7 @@ struct mlu_memory_ctx {
 	int device_id;
 	CNdev cnDevice;
 	CNcontext cnContext;
-
+	bool use_dmabuf;
 };
 
 
@@ -129,6 +129,18 @@ int mlu_memory_init(struct memory_ctx *ctx) {
 		return FAILURE;
 	}
 
+#ifdef HAVE_MLU_DMABUF
+	if (mlu_ctx->use_dmabuf) {
+		int is_supported = 0;
+
+		ERROR_CHECK(cnDeviceGetAttribute(&is_supported, CN_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED, mlu_ctx->cnDevice));
+		if (!is_supported) {
+			fprintf(stderr, "DMA-BUF is not supported on this MLU\n");
+			return FAILURE;
+		}
+	}
+#endif
+
 	return SUCCESS;
 }
 
@@ -144,8 +156,8 @@ int mlu_memory_allocate_buffer(struct memory_ctx *ctx, int alignment, uint64_t s
 				uint64_t *dmabuf_offset, void **addr, bool *can_init) {
 	CNresult error;
 	size_t buf_size = (size + ACCEL_PAGE_SIZE - 1) & ~(ACCEL_PAGE_SIZE - 1);
-
 	CNaddr mlu_addr;
+
 	printf("cnMalloc() of a %lu bytes MLU buffer\n", size);
 
 	error = cnMalloc(&mlu_addr, buf_size);
@@ -157,6 +169,35 @@ int mlu_memory_allocate_buffer(struct memory_ctx *ctx, int alignment, uint64_t s
 	printf("allocated %lu bytes of MLU buffer at %ld\n", (unsigned long)buf_size, mlu_addr);
 	*addr = (void *)mlu_addr;
 	*can_init = false;
+
+#ifdef HAVE_MLU_DMABUF
+	struct mlu_memory_ctx *mlu_ctx = container_of(ctx, struct mlu_memory_ctx, base);
+
+	{
+		if (mlu_ctx->use_dmabuf) {
+			CNaddr aligned_ptr;
+			const size_t host_page_size = sysconf(_SC_PAGESIZE);
+			uint64_t offset;
+			size_t aligned_size;
+
+			// Round down to host page size
+			aligned_ptr = mlu_addr & ~(host_page_size - 1);
+			offset = mlu_addr - aligned_ptr;
+			aligned_size = (size + offset + host_page_size - 1) & ~(host_page_size - 1);
+
+			printf("using DMA-BUF for MLU buffer address at %#lx aligned at %#lx with aligned size %zu\n", mlu_addr, aligned_ptr, aligned_size);
+			*dmabuf_fd = 0;
+			error = cnMemGetHandleForAddressRange((void *)dmabuf_fd, aligned_ptr, aligned_size, CN_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD, 0);
+			if (error != CN_SUCCESS) {
+				printf("cnMemGetHandleForAddressRange error=%d\n", error);
+				return FAILURE;
+			}
+
+			*dmabuf_offset = offset;
+		}
+	}
+#endif
+
 	return SUCCESS;
 }
 
@@ -182,6 +223,14 @@ bool mlu_memory_supported() {
 	return true;
 }
 
+bool mlu_memory_dmabuf_supported() {
+#ifdef HAVE_MLU_DMABUF
+	return true;
+#else
+	return false;
+#endif
+}
+
 struct memory_ctx *mlu_memory_create(struct perftest_parameters *params) {
 	struct mlu_memory_ctx *ctx;
 
@@ -194,6 +243,7 @@ struct memory_ctx *mlu_memory_create(struct perftest_parameters *params) {
 	ctx->base.copy_buffer_to_host = mlu_memory_copy_host_buffer;
 	ctx->base.copy_buffer_to_buffer = mlu_memory_copy_buffer_to_buffer;
 	ctx->device_id = params->mlu_device_id;
+	ctx->use_dmabuf = params->use_mlu_dmabuf;
 
 	return &ctx->base;
 }

src/mlu_memory.h

@@ -16,6 +16,8 @@ struct perftest_parameters;
 
 bool mlu_memory_supported();
 
+bool mlu_memory_dmabuf_supported();
+
 struct memory_ctx *mlu_memory_create(struct perftest_parameters *params);
 
 
@@ -25,6 +27,10 @@ inline bool mlu_memory_supported() {
 	return false;
 }
 
+inline bool mlu_memory_dmabuf_supported() {
+	return false;
+}
+
 inline struct memory_ctx *mlu_memory_create(struct perftest_parameters *params) {
 	return NULL;
 }

src/perftest_parameters.c

@@ -668,6 +668,11 @@ static void usage(const char *argv0, VerbType verb, TestType tst, int connection
 		if (mlu_memory_supported()) {
 			printf("      --use_mlu=<mlu device id>");
 			printf(" Use selected MLU device for MLUDirect RDMA testing\n");
+
+			if (mlu_memory_dmabuf_supported()) {
+				printf("      --use_mlu_dmabuf");
+				printf(" Use DMA-BUF for HW accelerator direct RDMA testing\n");
+			}
 		}
 
 		if (opencl_memory_supported()) {
@@ -913,6 +918,7 @@ static void init_perftest_params(struct perftest_parameters *user_param)
 	user_param->rocm_device_id	= 0;
 	user_param->neuron_core_id	= 0;
 	user_param->mlu_device_id	= 0;
+	user_param->use_mlu_dmabuf	= 0;
 	user_param->opencl_platform_id	= 0;
 	user_param->opencl_device_id	= 0;
 	user_param->gpu_touch		= GPU_NO_TOUCH;
@@ -1897,6 +1903,18 @@ static void force_dependecies(struct perftest_parameters *user_param)
 		exit(1);
 	}
 
+	if (user_param->memory_type == MEMORY_MLU && user_param->tst == LAT && (user_param->verb == WRITE || user_param->verb == WRITE_IMM)) {
+		printf(RESULT_LINE);
+		fprintf(stderr,"Perftest supports MLU latency tests with read/send verbs only\n");
+		exit(1);
+	}
+
+	if (user_param->memory_type == MEMORY_MLU && (int)user_param->size <= user_param->inline_size) {
+		printf(RESULT_LINE);
+		fprintf(stderr,"Perftest doesn't support MLU tests with inline messages\n");
+		exit(1);
+	}
+
 	if (user_param->use_data_direct) {
 		user_param->use_cuda_pcie_mapping = 1;
 	}
@@ -2333,6 +2351,12 @@ static void ctx_set_max_inline(struct ibv_context *context,struct perftest_param
 			return;
 		}
 
+		if (user_param->memory_type == MEMORY_MLU){
+			user_param->inline_size = 0;
+			printf("Perftest doesn't supports MLU tests with inline messages: inline size set to 0\n");
+			return;
+		}
+
 		if (user_param->tst == LAT) {
 			switch(user_param->verb) {
 				case WRITE_IMM:
@@ -2434,6 +2458,7 @@ int parser(struct perftest_parameters *user_param,char *argv[], int argc)
 	static int use_neuron_dmabuf_flag = 0;
 	static int use_hl_flag = 0;
 	static int use_mlu_flag = 0;
+	static int use_mlu_dmabuf_flag = 0;
 	static int use_opencl_flag = 0;
 	static int opencl_platform_id_flag = 0;
 	static int gpu_touch_flag = 0;
@@ -2614,6 +2639,7 @@ int parser(struct perftest_parameters *user_param,char *argv[], int argc)
 			{ .name = "use_neuron_dmabuf",	.has_arg = 0, .flag = &use_neuron_dmabuf_flag, .val = 1},
 			{ .name = "use_hl",		.has_arg = 1, .flag = &use_hl_flag, .val = 1},
 			{ .name = "use_mlu",		.has_arg = 1, .flag = &use_mlu_flag, .val = 1},
+			{ .name = "use_mlu_dmabuf",	.has_arg = 0, .flag = &use_mlu_dmabuf_flag, .val = 1},
 			{ .name = "use_opencl",         .has_arg = 1, .flag = &use_opencl_flag, .val = 1},
 			{ .name = "opencl_platform_id", .has_arg = 1, .flag = &opencl_platform_id_flag, .val = 1},
 			{ .name = "gpu_touch",		.has_arg = 1, .flag = &gpu_touch_flag, .val = 1},
@@ -3061,6 +3087,7 @@ int parser(struct perftest_parameters *user_param,char *argv[], int argc)
 				    (use_neuron_dmabuf_flag && !neuron_memory_dmabuf_supported()) ||
 				    (use_hl_flag && !hl_memory_supported()) ||
 				    (use_mlu_flag && !mlu_memory_supported()) ||
+				    (use_mlu_dmabuf_flag && !mlu_memory_dmabuf_supported()) ||
 				    (use_opencl_flag && !opencl_memory_supported())) {
 					printf(" Unsupported memory type\n");
 					return FAILURE;
@@ -3175,6 +3202,15 @@ int parser(struct perftest_parameters *user_param,char *argv[], int argc)
 					user_param->memory_create = mlu_memory_create;
 					use_mlu_flag = 0;
 				}
+				if (use_mlu_dmabuf_flag) {
+					user_param->use_mlu_dmabuf = 1;
+					if (user_param->memory_type != MEMORY_MLU) {
+						fprintf(stderr, "MLU DMA-BUF cannot be used without MLU device\n");
+						free(duplicates_checker);
+						return FAILURE;
+					}
+					use_mlu_dmabuf_flag = 0;
+				}
 
 				if (use_opencl_flag) {
 					CHECK_VALUE_NON_NEGATIVE(user_param->opencl_device_id,int,"OPENCL device",not_int_ptr);

src/perftest_parameters.h

@@ -599,6 +599,7 @@ struct perftest_parameters {
 	int				use_neuron_dmabuf;
 	char				*hl_device_bus_id;
 	int				mlu_device_id;
+	int				use_mlu_dmabuf;
 	int                             opencl_platform_id;
 	int                             opencl_device_id;
 	int                             gpu_touch;