自学教程：C++ FT_PRINTERR函数代码示例

int ft_start_server(void){	int ret;	ret = ft_getinfo(hints, &fi_pep);	if (ret)		return ret;	ret = fi_fabric(fi_pep->fabric_attr, &fabric, NULL);	if (ret) {		FT_PRINTERR("fi_fabric", ret);		return ret;	}	ret = fi_eq_open(fabric, &eq_attr, &eq, NULL);	if (ret) {		FT_PRINTERR("fi_eq_open", ret);		return ret;	}	ret = fi_passive_ep(fabric, fi_pep, &pep, NULL);	if (ret) {		FT_PRINTERR("fi_passive_ep", ret);		return ret;	}	ret = fi_pep_bind(pep, &eq->fid, 0);	if (ret) {		FT_PRINTERR("fi_pep_bind", ret);		return ret;	}	ret = fi_listen(pep);	if (ret) {		FT_PRINTERR("fi_listen", ret);		return ret;	}	return 0;}

static int run_test(void){	int ret = 0;	ret = init_fabric();	if (ret)		return ret;	if (opts.dst_addr) {			/* Execute RMA write operation from Client */		fprintf(stdout, "RMA write to server/n");		sprintf(buf, "%s", welcome_text);		ret = write_data(sizeof(char *) * strlen(buf));		if (ret)			return ret;			ret = fi_cntr_wait(scntr, 1, -1);		if (ret < 0) {			FT_PRINTERR("fi_cntr_wait", ret);			return ret;		}		fprintf(stdout, "Received a completion event for RMA write/n");	} else {			/* Server waits for message from Client */		ret = fi_cntr_wait(rcntr, 1, -1);		if (ret < 0) {			FT_PRINTERR("fi_cntr_wait", ret);			return ret;		}		fprintf(stdout, "Received data from Client: %s/n", (char *)buf);	}	/* TODO: need support for finalize operation to sync test */	free_ep_res();	fi_close(&dom->fid);	fi_close(&fab->fid);	return 0;}

int ft_finalize(void){	struct iovec iov;	int ret;	struct fi_context ctx;	void *desc = fi_mr_desc(mr);	strcpy(tx_buf + ft_tx_prefix_size(), "fin");	iov.iov_base = tx_buf;	iov.iov_len = 4 + ft_tx_prefix_size();	if (hints->caps & FI_TAGGED) {		struct fi_msg_tagged tmsg;		memset(&tmsg, 0, sizeof tmsg);		tmsg.msg_iov = &iov;		tmsg.desc = &desc;		tmsg.iov_count = 1;		tmsg.addr = remote_fi_addr;		tmsg.tag = tx_seq;		tmsg.ignore = 0;		tmsg.context = &ctx;		ret = fi_tsendmsg(ep, &tmsg, FI_INJECT | FI_TRANSMIT_COMPLETE);	} else {		struct fi_msg msg;		memset(&msg, 0, sizeof msg);		msg.msg_iov = &iov;		msg.desc = &desc;		msg.iov_count = 1;		msg.addr = remote_fi_addr;		msg.context = &ctx;		ret = fi_sendmsg(ep, &msg, FI_INJECT | FI_TRANSMIT_COMPLETE);	}	if (ret) {		FT_PRINTERR("transmit", ret);		return ret;	}	ret = ft_get_tx_comp(++tx_seq);	if (ret)		return ret;	ret = ft_get_rx_comp(rx_seq);	if (ret)		return ret;	return 0;}

static int write_data_with_cq_data(size_t size){	int ret;	ret = fi_writedata(ep, buf, size, fi_mr_desc(mr), cq_data,			remote_fi_addr, remote.addr, remote.key,			&fi_ctx_writedata);	if (ret) {		FT_PRINTERR("fi_writedata", ret);		return ret;	}	return 0;}

int ft_bind_comp(struct fid_ep *ep, uint64_t flags){	int ret;	if (flags & FI_SEND) {		ret = fi_ep_bind(ep, &txcq->fid, flags & ~FI_RECV);		if (ret) {			FT_PRINTERR("fi_ep_bind", ret);			return ret;		}	}	if (flags & FI_RECV) {		ret = fi_ep_bind(ep, &rxcq->fid, flags & ~FI_SEND);		if (ret) {			FT_PRINTERR("fi_ep_bind", ret);			return ret;		}	}	return 0;}

static int recv_msg(void){	int ret;	ret = fi_recv(srx_ctx, buf, rx_size, fi_mr_desc(mr), 0, &rx_ctx);	if (ret) {		FT_PRINTERR("fi_recv", ret);		return ret;	}	ret = ft_get_rx_comp(++rx_seq);	return ret;}

static int write_data(size_t size){	int ret;		/* Using specified base address and MR key for RMA write */	ret = fi_write(ep, buf, size, fi_mr_desc(mr), remote_fi_addr, 0, 			user_defined_key, &fi_ctx_write);	if (ret){		FT_PRINTERR("fi_write", ret);		return ret;	}	return 0;}

static int alloc_cm_res(void){	struct fi_eq_attr cm_attr;	int ret;	memset(&cm_attr, 0, sizeof cm_attr);	cm_attr.wait_obj = FI_WAIT_FD;	ret = fi_eq_open(fab, &cm_attr, &cmeq, NULL);	if (ret)		FT_PRINTERR("fi_eq_open", ret);	return ret;}

static int pp_post_send(struct pingpong_context *ctx){	int rc = 0;	rc = fi_send(ctx->ep, ctx->buf, ctx->size, fi_mr_desc(ctx->mr),		     0, (void *)(uintptr_t)PINGPONG_SEND_WCID);	if (rc) {		FT_PRINTERR("fi_send", rc);		return 1;	}	return 0;}

static int read_data(size_t size){	int ret;	ret = fi_read(ep, buf, size, fi_mr_desc(mr), 		      0, remote.addr, remote.key, ep);	if (ret) {		FT_PRINTERR("fi_read", ret);		return ret;	}	return 0;}

static int send_msg(int size, uint64_t tag){	int ret;	ret = fi_tsend(ep, buf, (size_t) size, fi_mr_desc(mr), remote_fi_addr,			tag, &fi_ctx_send);	if (ret)		FT_PRINTERR("fi_tsend", ret);	ret = wait_for_tagged_completion(scq, 1);	return ret;}

static int bind_ep_res(void){	int i, ret;	ret = fi_scalable_ep_bind(sep, &av->fid, 0);	if (ret) {		FT_PRINTERR("fi_scalable_ep_bind", ret);		return ret;	}	for (i = 0; i < ctx_cnt; i++) {		ret = fi_ep_bind(tx_ep[i], &txcq_array[i]->fid, FI_SEND);		if (ret) {			FT_PRINTERR("fi_ep_bind", ret);			return ret;		}		ret = fi_enable(tx_ep[i]);		if (ret) {			FT_PRINTERR("fi_enable", ret);			return ret;		}	}	for (i = 0; i < ctx_cnt; i++) {		ret = fi_ep_bind(rx_ep[i], &rxcq_array[i]->fid, FI_RECV);		if (ret) {			FT_PRINTERR("fi_ep_bind", ret);			return ret;		}		ret = fi_enable(rx_ep[i]);		if (ret) {			FT_PRINTERR("fi_enable", ret);			return ret;		}		ret = fi_recv(rx_ep[i], rx_buf, MAX(rx_size, FT_MAX_CTRL_MSG),			      mr_desc, 0, NULL);		if (ret) {			FT_PRINTERR("fi_recv", ret);			return ret;		}	}	ret = fi_enable(sep);	if (ret) {		FT_PRINTERR("fi_enable", ret);		return ret;	}	return 0;}

static int recv_xfer(int size){	struct fi_cq_data_entry comp;	int ret;	do {		ret = fi_cq_read(rcq, &comp, 1);		if (ret < 0 && ret != -FI_EAGAIN) {			if (ret == -FI_EAVAIL) {				cq_readerr(rcq, "rcq");			} else {				FT_PRINTERR("fi_cq_read", ret);			}			return ret;		}	} while (ret == -FI_EAGAIN);	ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), 0, buf);	if (ret)		FT_PRINTERR("fi_recv", ret);	return ret;}

static int execute_base_atomic_op(enum fi_op op){	int ret;		ret = fi_atomic(ep, buf, 1, fi_mr_desc(mr), remote_fi_addr, remote.addr,		       	remote.key, datatype, op, &fi_ctx_atomic);	if (ret) {		FT_PRINTERR("fi_atomic", ret);	} else {								ret = wait_for_completion(scq, 1);	}		return ret;}

static int recv_msg(void){	int ret;	ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), 0, &fi_ctx_recv);	if (ret) {		FT_PRINTERR("fi_recv", ret);		return ret;	}	ret = wait_for_completion(rcq, 1);	return ret;}

static int recv_msg(void){	int ret;	ret = fi_recv(ep, buf, rx_size, fi_mr_desc(mr), 0, &fi_ctx_recv);	if (ret) {		FT_PRINTERR("fi_recv", ret);		return ret;	}	ret = ft_wait_for_comp(rxcq, 1);	return ret;}

int main(int argc, char **argv){	int op, ret;	int failed = 0;	hints = fi_allocinfo();	if (!hints)		return EXIT_FAILURE;	while ((op = getopt(argc, argv, FAB_OPTS "h")) != -1) {		switch (op) {		default:			ft_parseinfo(op, optarg, hints, &opts);			break;		case '?':		case 'h':			usage();			return EXIT_FAILURE;		}	}	hints->mode = ~0;	hints->domain_attr->mode = ~0;	hints->domain_attr->mr_mode = ~(FI_MR_BASIC | FI_MR_SCALABLE);	ret = fi_getinfo(FT_FIVERSION, NULL, 0, 0, hints, &fi);	if (ret) {		FT_PRINTERR("fi_getinfo", ret);		goto out;	}	if (!fi->domain_attr->cntr_cnt)		goto out;	ret = ft_open_fabric_res();	if (ret)		goto out;	printf("Testing CNTRS on fabric %s/n", fi->fabric_attr->name);	failed = run_tests(test_array, err_buf);	if (failed > 0)		printf("Summary: %d tests failed/n", failed);	else		printf("Summary: all tests passed/n");out:	ft_free_res();	return ret ? ft_exit_code(ret) : (failed > 0) ? EXIT_FAILURE : EXIT_SUCCESS;}

int ft_cq_readerr(struct fid_cq *cq){	struct fi_cq_err_entry cq_err;	int ret;	ret = fi_cq_readerr(cq, &cq_err, 0);	if (ret < 0) {		FT_PRINTERR("fi_cq_readerr", ret);	} else {		FT_CQ_ERR(cq, cq_err, NULL, 0);		ret = -cq_err.err;	}	return ret;}

static int post_recvs(struct cma_node *node){	int i, ret = 0;	for (i = 0; i < hints->tx_attr->size && !ret; i++ ) {		ret = fi_recv(node->ep, node->mem, hints->ep_attr->max_msg_size,				node->mrdesc, 0, node);		if (ret) {			FT_PRINTERR("fi_recv", ret);			break;		}	}	return ret;}

static int send_msg(int size){	int ret;	ret = fi_send(ep_array[0], buf, (size_t) size, fi_mr_desc(mr),			addr_array[0], &tx_ctx);	if (ret) {		FT_PRINTERR("fi_send", ret);		return ret;	}	ret = ft_get_tx_comp(++tx_seq);	return ret;}

static int pp_eq_create(struct pingpong_context *ctx){	struct fi_eq_attr cm_attr;	int rc;	memset(&cm_attr, 0, sizeof cm_attr);	cm_attr.wait_obj 	= FI_WAIT_FD;	rc = fi_eq_open(ctx->fabric, &cm_attr, &ctx->eq, NULL);	if (rc)		FT_PRINTERR("fi_eq_open", rc);	return rc;}

static int bind_ep_res(void){	int ret;	ret = fi_ep_bind(ep, &scq->fid, FI_SEND | FI_READ | FI_WRITE);	if (ret) {		FT_PRINTERR("fi_ep_bind", -ret);		return ret;	}	ret = fi_ep_bind(ep, &rcq->fid, FI_RECV);	if (ret) {		FT_PRINTERR("fi_ep_bind", -ret);		return ret;	}	ret = fi_ep_bind(ep, &av->fid, FI_RECV);	if (ret) {		FT_PRINTERR("fi_ep_bind", ret);		return ret;	}	ret = fi_enable(ep);	if(ret) {		FT_PRINTERR("fi_enable", ret);		return ret;	}		/* Post the first recv buffer */	ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), 0, &fi_ctx_recv);	if (ret) {		FT_PRINTERR("fi_recv", ret);		return ret;	}	return ret;}

static int bind_ep_res(void){	int ret;	ret = fi_ep_bind(ep, &scq->fid, FI_SEND);	if (ret) {		FT_PRINTERR("fi_ep_bind", ret);		return ret;	}	ret = fi_ep_bind(ep, &rcq->fid, FI_RECV);	if (ret) {		FT_PRINTERR("fi_ep_bind", ret);		return ret;	}	ret = fi_ep_bind(ep, &av->fid, 0);	if (ret) {		FT_PRINTERR("fi_ep_bind", ret);		return ret;	}	ret = fi_enable(ep);	if (ret) {		FT_PRINTERR("fi_enable", ret);		return ret;	}	/* Post a recv buffer for synchronization */	ret = fi_recv(ep, buf, buffer_size, fi_mr_desc(mr), 0, &fi_ctx_recv);	if (ret) {		FT_PRINTERR("fi_recv", ret);		return ret;	}	return ret;}

static int receive_loop(size_t size){	int ret;	int q_opts = 0;	struct fi_context recv_ctx[max_opts];	while (q_opts < max_opts) {		do {			ft_tag = q_opts + 1;			if (tagged)				ret = fi_trecv(ep, rx_buf, size, NULL, remote_fi_addr,					ft_tag, 0x0, (void *) &recv_ctx[q_opts]);			else				ret = fi_recv(ep, rx_buf, size, NULL, remote_fi_addr,					(void *) &recv_ctx[q_opts]);			if (ret == FI_SUCCESS) {				rx_seq++;				q_opts++;			}		} while (!ret && (q_opts != max_opts));		if (ret < 0) {			if (ret == -FI_EAGAIN) {				if (delay > 0)					sleep(delay);				ret = ft_get_rx_comp(rx_seq);				if (ret)					return ret;			} else {				FT_PRINTERR("Recv OP", ret);				return ret;			}		}	}	if (delay > 0)		sleep(delay);	ret = ft_get_rx_comp(rx_seq);	if (ret)		return ret;	if (opts.verbose)		printf("Success: Completed %d queued ops/n", q_opts);	return 0;}

static int run_client(void){	int i, ret, ret2;	printf("cmatose: starting client/n");	printf("cmatose: connecting/n");	for (i = 0; i < connections; i++) {		ret = fi_connect(nodes[i].ep, info->dest_addr, NULL, 0);		if (ret) {			FT_PRINTERR("fi_connect", ret);			connects_left--;			return ret;		}	}	ret = connect_events();	if (ret)		goto disc;	if (hints->tx_attr->size) {		printf("receiving data transfers/n");		ret = poll_cqs(RECV_CQ_INDEX);		if (ret)			goto disc;		printf("sending replies/n");		for (i = 0; i < connections; i++) {			ret = post_sends(nodes + i);			if (ret)				goto disc;		}		printf("completing sends/n");		ret = poll_cqs(SEND_CQ_INDEX);		if (ret)			goto disc;		printf("data transfers complete/n");	}	ret = 0;disc:	ret2 = shutdown_events(); 	printf("disconnected/n");	if (ret2)		ret = ret2;	return ret;}

int ft_eq_readerr(void){	struct fi_eq_err_entry err;	ssize_t ret;	ret = fi_eq_readerr(eq, &err, 0);	if (ret != sizeof(err)) {		FT_PRINTERR("fi_eq_readerr", ret);		return ret;	} else {		fprintf(stderr, "Error event %d %s/n",			err.err, fi_strerror(err.err));		return err.err;	}}

static int send_xfer(int size){	struct fi_cq_entry comp;	int ret;	while (!credits) {		ret = fi_cq_read(scq, &comp, 1);		if (ret > 0) {			goto post;		} else if (ret < 0 && ret != -FI_EAGAIN) {			FT_PRINTERR("fi_cq_read", ret);			return ret;		}	}	credits--;post:	ret = fi_send(ep, buf_ptr, (size_t) size, fi_mr_desc(mr),			remote_fi_addr, NULL);	if (ret)		FT_PRINTERR("fi_send", ret);	return ret;}

static int recv_msg(uint64_t tag){	int ret;	// posting recv for next send	ret = fi_trecv(ep, buf, buffer_size, fi_mr_desc(mr), remote_fi_addr,			tag, 0, &fi_ctx_recv);	if (ret)		FT_PRINTERR("fi_trecv", ret);		// wait for the completion event	ret = wait_for_tagged_completion(rcq, 1);	return ret;}

static int send_msg(int size){	int ret;	ret = fi_send(ep, buf, (size_t) size, fi_mr_desc(mr), remote_fi_addr,			&fi_ctx_send);	if (ret) {		FT_PRINTERR("fi_send", ret);		return ret;	}	ret = ft_wait_for_comp(txcq, 1);	return ret;}

int ft_open_fabric_res(void){	int ret;	ret = fi_fabric(fi->fabric_attr, &fabric, NULL);	if (ret) {		FT_PRINTERR("fi_fabric", ret);		return ret;	}	ret = fi_eq_open(fabric, &eq_attr, &eq, NULL);	if (ret) {		FT_PRINTERR("fi_eq_open", ret);		return ret;	}	ret = fi_domain(fabric, fi, &domain, NULL);	if (ret) {		FT_PRINTERR("fi_domain", ret);		return ret;	}	return 0;}