示例#1
0
static int run_test(void)
{
	int ret, i;

	ret = sync_test();
	if (ret) {
		fprintf(stderr, "sync_test failed!\n");
		goto out;
	}

	ft_start();
	if (opts.dst_addr) {
		for (i = 0; i < opts.iterations; i++) {
			ret = ft_tx(ep, remote_fi_addr, opts.transfer_size, &tx_ctx);
			if (ret)
				goto out;
		}
	} else {
		ret = wait_for_recv_completion(opts.iterations);
		if (ret)
			goto out;
	}
	ft_stop();

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations,
			&start, &end, 1, opts.argc, opts.argv);
	else
		show_perf(test_name, opts.transfer_size, opts.iterations,
			&start, &end, 1);

out:
	return ret;
}
示例#2
0
static int run_test(void)
{
	int ret, i;

	ret = ft_sync();
	if (ret)
		return ret;

	ft_start();
	for (i = 0; i < opts.iterations; i++) {
		ret = ft_rma(opts.rma_op, ep, opts.transfer_size, &remote, ep);
		if (ret)
			return ret;
	}
	ft_stop();

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations, &start, &end,
				1, opts.argc, opts.argv);
	else
		show_perf(NULL, opts.transfer_size, opts.iterations,
				&start, &end, 1);

	return 0;
}
示例#3
0
static int run_test(void)
{
	int ret, i;

	ret = sync_test();
	if (ret)
		return ret;

	clock_gettime(CLOCK_MONOTONIC, &start);
	for (i = 0; i < opts.iterations; i++) {
		ret = opts.dst_addr ? send_xfer(opts.transfer_size) :
				 recv_xfer(opts.transfer_size);
		if (ret)
			return ret;

		ret = opts.dst_addr ? recv_xfer(opts.transfer_size) :
				 send_xfer(opts.transfer_size);
		if (ret)
			return ret;
	}
	clock_gettime(CLOCK_MONOTONIC, &end);

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations, &start, &end, 2, opts.argc, opts.argv);
	else
		show_perf(test_name, opts.transfer_size, opts.iterations, &start, &end, 2);

	return 0;
}
示例#4
0
static int run_test(void)
{
	int ret, i, t;

	ret = sync_test();
	if (ret)
		goto out;

	gettimeofday(&start, NULL);
	for (i = 0; i < iterations; i++) {
		for (t = 0; t < transfer_count; t++) {
			ret = dst_addr ? send_xfer(transfer_size) :
					 recv_xfer(transfer_size);
			if (ret)
				goto out;
		}

		for (t = 0; t < transfer_count; t++) {
			ret = dst_addr ? recv_xfer(transfer_size) :
					 send_xfer(transfer_size);
			if (ret)
				goto out;
		}
	}
	gettimeofday(&end, NULL);
	show_perf();
	ret = 0;

out:
	return ret;
}
示例#5
0
int pingpong(void)
{
	int ret, i;

	ret = ft_sync();
	if (ret)
		return ret;

	ft_start();
	for (i = 0; i < opts.iterations; i++) {
		ret = opts.dst_addr ?
			ft_tx(opts.transfer_size) : ft_rx(opts.transfer_size);
		if (ret)
			return ret;

		ret = opts.dst_addr ?
			ft_rx(opts.transfer_size) : ft_tx(opts.transfer_size);
		if (ret)
			return ret;
	}
	ft_stop();

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations, &start, &end, 2, opts.argc, opts.argv);
	else
		show_perf(test_name, opts.transfer_size, opts.iterations, &start, &end, 2);

	return 0;
}
示例#6
0
static int run_test(void)
{
	int ret, i;

	ret = sync_test();
	if (ret)
		goto out;

	clock_gettime(CLOCK_MONOTONIC, &start);
	for (i = 0; i < iterations; i++) {
		ret = dst_addr ? send_xfer(transfer_size) :
				 recv_xfer(transfer_size);
		if (ret)
			goto out;

		ret = dst_addr ? recv_xfer(transfer_size) :
				 send_xfer(transfer_size);
		if (ret)
			goto out;
	}
	clock_gettime(CLOCK_MONOTONIC, &end);
	show_perf(test_name, transfer_size, iterations, &start, &end, 2);
	ret = 0;

out:
	return ret;
}
示例#7
0
文件: bw.c 项目: soniczhao/fabtests
static int run_test(void)
{
	int ret = 0, i;

	if ((ret = sync_test())) {
		goto out;
	}

	if (bidir || client) {
		gettimeofday(&start, NULL);
		for (i = 0; i < iterations; i++) {
			if ((ret = write_xfer(transfer_size))) {
				goto out;
			}
		}
		if ((ret = poll_all_sends())) {
			goto out;
		}
		gettimeofday(&end, NULL);
		show_perf();
	}

	if ((ret = sync_test())) {
		goto out;
	}

out:
	return ret;
}
示例#8
0
static int stream(void)
{
	int ret, i;

	ret = ft_sync();
	if (ret)
		return ret;

	ft_start();
	for (i = 0; i < opts.iterations; i++) {
		ret = opts.dst_addr ?
			ft_tx(ep, remote_fi_addr, opts.transfer_size, &tx_ctx) : ft_rx(ep, opts.transfer_size);
		if (ret)
			return ret;
	}
	ft_stop();

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations, &start, &end, 1,
			     opts.argc, opts.argv);
	else
		show_perf(NULL, opts.transfer_size, opts.iterations, &start, &end, 1);

	return 0;
}
示例#9
0
static int run_op(void)
{
	int ret, i;

	count = (size_t *) malloc(sizeof(size_t));
	sync_test();
	clock_gettime(CLOCK_MONOTONIC, &start);
	
	switch (op_type) {
	case FI_MIN:
	case FI_MAX:
	case FI_ATOMIC_READ:
	case FI_ATOMIC_WRITE:
		ret = is_valid_base_atomic_op(op_type);
		if (ret > 0) {
			for (i = 0; i < iterations; i++) {
				ret = execute_base_atomic_op(op_type);
				if (ret)
					break;
			}
		}

		ret = is_valid_fetch_atomic_op(op_type);
		if (ret > 0) {
			for (i = 0; i < iterations; i++) {
				ret = execute_fetch_atomic_op(op_type);
				if (ret)
					break;
			}
		}
		break;
	case FI_CSWAP:
		ret = is_valid_compare_atomic_op(op_type);
		if (ret > 0) {
			ret = execute_compare_atomic_op(op_type);
		} else {
			goto out;
		}
		break;
	default:
		ret = -EINVAL;
		goto out;
	}

	clock_gettime(CLOCK_MONOTONIC, &end);
	
	if (ret)
		goto out;
		
	show_perf(test_name, transfer_size, iterations, &start, &end, 2);
	ret = 0;

out:
	free(count);
	return ret;
}
示例#10
0
static int run_test(void)
{
	int ret, i, t;
	off_t offset;
	uint8_t marker = 0;

	poll_byte = buf + transfer_size - 1;
	*poll_byte = -1;
	offset = riomap(rs, buf, transfer_size, PROT_WRITE, 0, 0);
	if (offset ==  -1) {
		perror("riomap");
		ret = -1;
		goto out;
	}
	ret = sync_test();
	if (ret)
		goto out;

	gettimeofday(&start, NULL);
	for (i = 0; i < iterations; i++) {
		if (dst_addr) {
			for (t = 0; t < transfer_count - 1; t++) {
				ret = send_xfer(transfer_size);
				if (ret)
					goto out;
			}
			*poll_byte = (uint8_t) marker++;
			ret = send_xfer(transfer_size);
			if (ret)
				goto out;

			ret = recv_xfer(transfer_size, marker++);
		} else {
			ret = recv_xfer(transfer_size, marker++);
			if (ret)
				goto out;

			for (t = 0; t < transfer_count - 1; t++) {
				ret = send_xfer(transfer_size);
				if (ret)
					goto out;
			}
			*poll_byte = (uint8_t) marker++;
			ret = send_xfer(transfer_size);
		}
		if (ret)
			goto out;
	}
	gettimeofday(&end, NULL);
	show_perf();
	ret = riounmap(rs, buf, transfer_size);

out:
	return ret;
}
示例#11
0
/*--------------------------------------------------------*/
void AzsSvrg::_train_test()
{  
  if (rseed > 0) {
    srand(rseed); /* initialize the random seed */
  }

  /*---  initialization  ---*/
  int dim = m_trn_x->rowNum(); 
  reset_weights(dim); 

  /*---  iterate ... ---*/
  AzTimeLog::print("---  Training begins ... ", log_out); 
  AzsSvrgData_fast prev_fast; 
  AzsSvrgData_compact prev_compact; 
  int ite;
  for (ite = 0; ite < ite_num; ++ite) {
    if (do_show_timing) AzTimeLog::print("---  iteration#", ite+1, log_out); 
    if (doing_svrg(ite) && (ite-sgd_ite) % svrg_interval == 0) {
      if (do_show_timing) AzTimeLog::print("Computing gradient average ... ", log_out); 
      if (do_compact) get_avg_gradient_compact(&prev_compact); 
      else            get_avg_gradient_fast(&prev_fast); 
    }  

    if (do_show_timing) AzTimeLog::print("Updating weights ... ", log_out); 
    AzIntArr ia_dxs; 
    const int *dxs = gen_seq(dataSize(), ia_dxs);   
    int ix; 
    for (ix = 0; ix < dataSize(); ++ix) {      
      int dx = dxs[ix];  /* data point index */
      AzDvect v_deriv(class_num); 
      get_deriv(dx, &v_deriv); /* compute the derivatives */
      if (doing_svrg(ite)) {
        if (do_compact) updateDelta_svrg_compact(dx, &v_deriv, prev_compact); 
        else            updateDelta_svrg_fast(dx, &v_deriv, prev_fast); 
      }
      else {
        updateDelta_sgd(dx, &v_deriv);       
      } 
      flushDelta(); 
    }
    show_perf(ite); 
  }

  if (do_show_timing) AzTimeLog::print("--- End of training ... ", log_out); 
  
  /*---  write predictions to a file if requested  ---*/
  if (s_pred_fn.length() > 0) {
    AzTimeLog::print("Writing predictions to ", s_pred_fn.c_str(), log_out); 
    write_pred(m_tst_x, s_pred_fn.c_str()); 
  }
}
示例#12
0
int pingpong(void)
{
	int ret, i;

	ret = ft_sync();
	if (ret)
		return ret;

	if (opts.dst_addr) {
		for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
			if (i == opts.warmup_iterations)
				ft_start();

			if (opts.transfer_size < fi->tx_attr->inject_size)
				ret = ft_inject(opts.transfer_size);
			else
				ret = ft_tx(opts.transfer_size);
			if (ret)
				return ret;

			ret = ft_rx(opts.transfer_size);
			if (ret)
				return ret;
		}
	} else {
		for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
			if (i == opts.warmup_iterations)
				ft_start();

			ret = ft_rx(opts.transfer_size);
			if (ret)
				return ret;

			if (opts.transfer_size < fi->tx_attr->inject_size)
				ret = ft_inject(opts.transfer_size);
			else
				ret = ft_tx(opts.transfer_size);
			if (ret)
				return ret;
		}
	}
	ft_stop();

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations, &start, &end, 2, opts.argc, opts.argv);
	else
		show_perf(NULL, opts.transfer_size, opts.iterations, &start, &end, 2);

	return 0;
}
示例#13
0
static int run_test(void)
{
	int ret, i;

	ret = sync_test();
	if (ret)
		return ret;

	clock_gettime(CLOCK_MONOTONIC, &start);
	for (i = 0; i < opts.iterations; i++) {
		switch (op_type) {
		case FT_RMA_WRITE:
			ret = write_data(opts.transfer_size);
			break;
		case FT_RMA_WRITEDATA:
			ret = write_data_with_cq_data(opts.transfer_size);
			if (ret)
				return ret;
			ret = wait_remote_writedata_completion();
			break;
		case FT_RMA_READ:
			ret = read_data(opts.transfer_size);
			break;
		}
		if (ret)
			return ret;

		ret = ft_wait_for_comp(txcq, 1);
		if (ret)
			return ret;
	}
	clock_gettime(CLOCK_MONOTONIC, &end);

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations, &start, &end,
				1, opts.argc, opts.argv);
	else
		show_perf(test_name, opts.transfer_size, opts.iterations,
				&start, &end, 1);

	return 0;
}
示例#14
0
static int ft_run_bandwidth(void)
{
	size_t recv_cnt;
	int ret, i;

	for (i = 0; i < ft_ctrl.size_cnt; i += ft_ctrl.inc_step) {
		ft_tx_ctrl.msg_size = ft_ctrl.size_array[i];
		if (ft_tx_ctrl.msg_size > fabric_info->ep_attr->max_msg_size)
			break;

		if (((test_info.class_function == FT_FUNC_INJECT) ||
			(test_info.class_function == FT_FUNC_INJECTDATA)) &&
			(ft_tx_ctrl.msg_size > fabric_info->tx_attr->inject_size))
			break;

		ft_ctrl.xfer_iter = test_info.test_flags & FT_FLAG_QUICKTEST ?
				5 : size_to_count(ft_tx_ctrl.msg_size);
		recv_cnt = ft_ctrl.xfer_iter;

		ret = ft_sync_test(0);
		if (ret)
			return ret;

		ret = ft_post_recv_bufs();
		if (ret)
			return ret;

		clock_gettime(CLOCK_MONOTONIC, &start);
		ret = (test_info.ep_type == FI_EP_DGRAM) ?
			ft_bw_dgram(&recv_cnt) : ft_bw();
		clock_gettime(CLOCK_MONOTONIC, &end);
		if (ret) {
			FT_PRINTERR("bw test failed!", ret);
			return ret;
		}

		show_perf("bw", ft_tx_ctrl.msg_size, recv_cnt, &start, &end, 1);
	}

	return 0;
}
示例#15
0
int bandwidth(void)
{
	int ret, i, j;

	ret = ft_sync();
	if (ret)
		return ret;

	/* The loop structured allows for the possibility that the sender
	 * immediately overruns the receiving side on the first transfer (or
	 * the entire window). This could result in exercising parts of the
	 * provider's implementation of FI_RM_ENABLED. For better or worse,
	 * some MPI-level benchmarks tend to use this type of loop for measuring
	 * bandwidth.  */

	if (opts.dst_addr) {
		for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
			if (i == opts.warmup_iterations)
				ft_start();

			for(j = 0; j < opts.window_size; j++) {
				if (opts.transfer_size < fi->tx_attr->inject_size)
					ret = ft_inject(opts.transfer_size);
				else
					ret = ft_post_tx(opts.transfer_size);
				if (ret)
					return ret;
			}
			ret = ft_get_tx_comp(tx_seq);
			if (ret)
				return ret;
			ret = ft_rx(4);
			if (ret)
				return ret;
		}
	} else {
		for (i = 0; i < opts.iterations + opts.warmup_iterations; i++) {
			if (i == opts.warmup_iterations)
				ft_start();

			for(j = 0; j < opts.window_size; j++) {
				ret = ft_post_rx(opts.transfer_size);
				if (ret)
					return ret;
			}
			ret = ft_get_rx_comp(rx_seq-1); /* rx_seq is always one ahead */
			if (ret)
				return ret;
			ret = ft_tx(4);
			if (ret)
				return ret;
		}
	}
	ft_stop();

	if (opts.machr)
		show_perf_mr(opts.transfer_size, opts.iterations, &start, &end,
				opts.window_size, opts.argc, opts.argv);
	else
		show_perf(NULL, opts.transfer_size, opts.iterations, &start, &end,
				opts.window_size);

	return 0;
}