C++ check_data函数代码示例

int tc_against_gold_v(struct ut_suite *suite, struct ut_tcase *tcase)
{
    size_t i;
    for (i = 0; i < ARRAY_SIZE(out1); i++) {
        ut_assert_msg(check_data(test_out1[i], out1[i], MAX_REL_DIFF) == OK,
                      "p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n",
                      i, out1[i], test_out1[i], test_out1[i]/out1[i]);
    }

    for (i = 0; i < ARRAY_SIZE(out2); i++) {
        ut_assert_msg(check_data(test_out2[i], out2[i], MAX_REL_DIFF) == OK,
                      "p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n",
                      i, out2[i], test_out2[i], test_out2[i]/out2[i]);
    }

#if 0
    //  This test is not used, since the code today requires nx >= ny
    for (i = 0; i < ARRAY_SIZE(out3); i++) {
        ut_assert_msg(check_data(test_out3[i], out3[i], MAX_REL_DIFF) == OK,
                      "p_xcorr_f32() Test 1: Large diff for index: %d, ref: %f, test: %f, rel: %f\n",
                      i, out3[i], test_out3[i], test_out3[i]/out3[i]);
    }
#endif

    return 0;
}

int main(int argc, char *argv[])
{

    // Stack variables
    float test_out[500];
    int testFail = 0;
    int i;

    printf("Running test program p_xcorr_test...\n");
    // Execution setup

    // Run test 1 on Arm
    p_xcorr_f32(in11, in12, test_out, in11_size, in12_size);

    // Check data
    for ( i = 0; i < out_size1; i++ ) {
      if (check_data(test_out[i],out1[i], MAX_REL_DIFF) == NOK ) {
        testFail = 1;
        printf("Test 1: Large diff for index %d, ref:%f   test: %f   rel:%f \n",i,out1[i],test_out[i], test_out[i]/out1[i]);
      }
    }

    // Run test 2 on Arm
    p_xcorr_f32(in21, in22, test_out, in21_size, in22_size);

    // Check data
    for ( i = 0; i < out_size2; i++ ) {
      if (check_data(test_out[i],out2[i], MAX_REL_DIFF) == NOK ) {
        testFail = 1;
        printf("Test 2: Large diff for index %d, ref:%f   test: %f   rel:%f \n",i,out2[i],test_out[i], test_out[i]/out2[i]);
      }
    }

    /*  // This test is not used, since the code today requires nx >= ny
    // Run test 3 on Arm
    p_xcorr_f32(in31, in32, test_out, in31_size, in32_size, 1, team0);

    // Check data
    for ( i = 0; i < out_size3; i++ ) {
      if (check_data(test_out[i],out3[i], MAX_REL_DIFF) == NOK ) {
	testOK = 0;
	printf("Test 3: Large diff for index %d, ref:%f   test: %f   rel:%f \n",i,out3[i],test_out[i], test_out[i]/out3[i]);
      }
    }
    */

    if (testFail) {
      printf("Xcorr ARM test FAILED!!\n");
    } else {
      printf("Xcorr ARM test OK\n");
    }

    return testFail;
}

static int remote_read(apacket *p, atransport *t)
{
    if(readx(t->sfd, &p->msg, sizeof(amessage))){
        D("remote local: read terminated (message)\n");
        return -1;
    }

    fix_endians(p);

#if 0 && defined __ppc__
    D("read remote packet: %04x arg0=%0x arg1=%0x data_length=%0x data_check=%0x magic=%0x\n",
      p->msg.command, p->msg.arg0, p->msg.arg1, p->msg.data_length, p->msg.data_check, p->msg.magic);
#endif
    if(check_header(p)) {
        D("bad header: terminated (data)\n");
        return -1;
    }

    if(readx(t->sfd, p->data, p->msg.data_length)){
        D("remote local: terminated (data)\n");
        return -1;
    }

    if(check_data(p)) {
        D("bad data: terminated (data)\n");
        return -1;
    }

    return 0;
}

int			get_map(t_glob *g)
{
	t_temp_list	*node;

	node = g->data;
	while (node->next != NULL)
	{
		ft_putstr(node->str);
		ft_putchar('\n');
		test_alpha(node->str);
		((g->lines == 0) && (test_digit(node->str) == 0)) ? g->ant_flag = 1 : 0;
		((ft_strcmp("##start", node->str)) == 0) ? g->start_flag = 1 : 0;
		((ft_strcmp("##end", node->str)) == 0) ? g->end_flag = 1 : 0;
		if ((ft_strncmp("#", node->str, 1)) == 0)
		{
			node = node->next;
			continue;
		}
		if (node->str == NULL)
			error();
		check_data(g, node->str);
		node = node->next;
	}
	if (validate(g))
		return (1);
	free(node);
	return (0);
}

int main(int argc, char *argv[])
{
    // Stack variables
    int i;
    float test_out[out_size];
    int testOK = 1;

    // Run the test on Arm
    p_rgb2grayscale_f32(in, test_out, in_rows, in_cols);

    // Check data
    for ( i = 0; i < out_size; i++ ) {
      if (check_data(test_out[i],out[i], MAX_REL_DIFF) == NOK ) {
	testOK = 0;
	printf("Large diff for index %d, ref:%f   test: %f   rel:%f \n",i,out[i],test_out[i], test_out[i]/out[i]);
      }
    }

    if ( testOK ){
      printf("RGB2Grayscale ARM test OK\n");
    } else {
      printf("RGB2Grayscale ARM test FAILED!!\n");
    }

}

// Implement response to initiator
tlm::tlm_sync_enum initiator::nb_transport_bw( PAYLOAD_TYPE& trans, tlm::tlm_phase& phase, sc_time& delay ) {
  cout << "[SC "<<sc_time_stamp()<<"] Starting nb_transport_bw of " << this->name() << endl;
   sc_assert(check_data(trans_count,&trans)==true);
  trans_count++; 
  cout << "[SC "<<sc_time_stamp()<<"] End of nb_transport_bw of " << this->name() << endl;
  return tlm::TLM_ACCEPTED;
}

static int remote_read(apacket *p, atransport *t)
{
    if(usb_read(t->usb, &p->msg, sizeof(amessage))){
        D("remote usb: read terminated (message)\n");
        return -1;
    }

    fix_endians(p);

    if(check_header(p)) {
        D("remote usb: check_header failed\n");
        return -1;
    }

    if(p->msg.data_length) {
        if(usb_read(t->usb, p->data, p->msg.data_length)){
            D("remote usb: terminated (data)\n");
            return -1;
        }
    }

    if(check_data(p)) {
        D("remote usb: check_data failed\n");
        return -1;
    }

    return 0;
}

static void do_write_wait(int len)
{
	uint64_t old_w_cnt, new_w_cnt;
	uint64_t old_r_cnt, new_r_cnt;
	ssize_t sz;
	const int iters = 100;
	int i;

	init_data(source, len, 0xab);
	init_data(target, len, 0);

	old_w_cnt = fi_cntr_read(write_cntr);
	old_r_cnt = fi_cntr_read(read_cntr);

	for (i = 0; i < iters; i++) {
		sz = fi_write(ep[0], source, len,
			      loc_mr, gni_addr[1], (uint64_t)target, mr_key,
			      target);
		cr_assert_eq(sz, 0);
	}

	fi_cntr_wait(write_cntr, old_w_cnt+iters, -1);
	new_w_cnt = fi_cntr_read(write_cntr);
	cr_assert(old_w_cnt + iters == new_w_cnt);

	cr_assert(check_data(source, target, len), "Data mismatch");

	new_r_cnt = fi_cntr_read(read_cntr);

	/*
	 * no fi_read called so old and new read cnts should be equal
	 */
	cr_assert(new_r_cnt == old_r_cnt);
}

void do_writedata(int len)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe, dcqe;

#define WRITE_DATA 0x5123da1a145
	init_data(source, len, 0x23);
	init_data(target, len, 0);
	sz = fi_writedata(ep[0], source, len, loc_mr, WRITE_DATA,
			 gni_addr[1], (uint64_t)target, mr_key,
			 target);
	cr_assert_eq(sz, 0);

	while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}

	cr_assert_eq(ret, 1);
	rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
	rdm_rma_check_cntrs(1, 0, 0, 0);

	dbg_printf("got write context event!\n");

	cr_assert(check_data(source, target, len), "Data mismatch");

	while ((ret = fi_cq_read(recv_cq, &dcqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}
	cr_assert(ret != FI_SUCCESS, "Missing remote data");

	rdm_rma_check_tcqe(&dcqe, NULL,
			   (FI_RMA | FI_REMOTE_WRITE | FI_REMOTE_CQ_DATA),
			   WRITE_DATA);
}

static void do_read(int len)
{
	ssize_t sz;
	uint64_t old_w_cnt, new_w_cnt;
	uint64_t old_r_cnt, new_r_cnt;

#define READ_CTX 0x4e3dda1aULL
	init_data(source, len, 0);
	init_data(target, len, 0xad);

	old_w_cnt = fi_cntr_read(write_cntr);
	old_r_cnt = fi_cntr_read(read_cntr);

	sz = fi_read(ep[0], source, len,
			loc_mr, gni_addr[1], (uint64_t)target, mr_key,
			(void *)READ_CTX);
	cr_assert_eq(sz, 0);

	do {
		new_r_cnt = fi_cntr_read(read_cntr);
		if (new_r_cnt == (old_r_cnt + 1))
			break;
		pthread_yield();
	} while (1);

	cr_assert(check_data(source, target, len), "Data mismatch");

	new_w_cnt = fi_cntr_read(write_cntr);

	/*
	 * no fi_read called so old and new read cnts should be equal
	 */
	cr_assert(new_w_cnt == old_w_cnt);
}

static int zynqmp_validate_bitstream(xilinx_desc *desc, const void *buf,
				   size_t bsize, u32 blocksize, u32 *swap)
{
	ulong *buf_start;
	ulong diff;

	buf_start = check_data((u8 *)buf, blocksize, swap);

	if (!buf_start)
		return FPGA_FAIL;

	/* Check if data is postpone from start */
	diff = (ulong)buf_start - (ulong)buf;
	if (diff) {
		printf("%s: Bitstream is not validated yet (diff %lx)\n",
		       __func__, diff);
		return FPGA_FAIL;
	}

	if ((ulong)buf < SZ_1M) {
		printf("%s: Bitstream has to be placed up to 1MB (%px)\n",
		       __func__, buf);
		return FPGA_FAIL;
	}

	return 0;
}

void do_readv(int len)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe;
	struct iovec iov;

	iov.iov_base = source;
	iov.iov_len = len;

	init_data(target, len, 0x25);
	init_data(source, len, 0);
	sz = fi_readv(ep[0], &iov, (void **)&loc_mr, 1,
		       gni_addr[1], (uint64_t)target, mr_key,
		       target);
	cr_assert_eq(sz, 0);

	while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}

	cr_assert_eq(ret, 1);
	rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_READ, 0);
	rdm_rma_check_cntrs(0, 1, 0, 0);

	dbg_printf("got write context event!\n");

	cr_assert(check_data(source, target, len), "Data mismatch");
}

void do_write_autoreg_uncached(int len)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe;

	init_data(uc_source, len, 0xab);
	init_data(target, len, 0);
	sz = fi_write(ep[0], uc_source, len,
			 NULL, gni_addr[1], (uint64_t)target, mr_key,
			 target);
	cr_assert_eq(sz, 0);

	while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}

	cr_assert_eq(ret, 1);
	rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
	rdm_rma_check_cntrs(1, 0, 0, 0);

	dbg_printf("got write context event!\n");

	cr_assert(check_data(uc_source, target, len), "Data mismatch");
}

int main(int argc, char **argv)
{
	if(sizeof(int) != 4) {
		fprintf(stderr, "Your machine's ints are not 4 bytes.  "
				"You need to adjust generate_data() and check_data().\n");
		exit(2);
	}

	process_args(argc, argv);
	init_genrand(opt_seed);

	if(opt_check) {
		check_data(0, opt_size);
	} else {
		generate_data(1, opt_size);
	}

	/*
	int i;
	printf("1000 outputs of genrand_int32()\n");
	for (i=0; i<1000; i++) {
		printf("%10lu ", genrand_int32());
		if (i%5==4) printf("\n");
	}
	*/

	return 0;
}

void do_read(int len)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe;

#define READ_CTX 0x4e3dda1aULL
	init_data(source, len, 0);
	init_data(target, len, 0xad);
	sz = fi_read(ep[0], source, len,
			loc_mr, gni_addr[1], (uint64_t)target, mr_key,
			(void *)READ_CTX);
	cr_assert_eq(sz, 0);

	while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}

	cr_assert_eq(ret, 1);
	rdm_rma_check_tcqe(&cqe, (void *)READ_CTX, FI_RMA | FI_READ, 0);
	rdm_rma_check_cntrs(0, 1, 0, 0);

	dbg_printf("got read context event!\n");

	cr_assert(check_data(source, target, len), "Data mismatch");
}