예제 #1
0
void sep_writedata(int index, int len)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
					  (void *) -1, UINT_MAX, UINT_MAX };
	struct fi_cq_tagged_entry dcqe = { (void *) -1, UINT_MAX, UINT_MAX,
					  (void *) -1, UINT_MAX, UINT_MAX };
	uint64_t w[2] = {0}, r[2] = {0}, w_e[2] = {0}, r_e[2] = {0};


#define WRITE_DATA 0x5123da1a145
	sep_init_data(source, len, 0x43 + index);
	sep_init_data(target, len, 0);
	sz = fi_writedata(tx_ep[0][index], source, len, loc_mr[0], WRITE_DATA,
			  rx_addr[index], (uint64_t)target, mr_key[1],
			  target);
	cr_assert_eq(sz, 0);

	while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}

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

	w[0] = 1;
	sep_check_cntrs(w, r, w_e, r_e);
	cr_assert(sep_check_data(source, target, len), "Data mismatch");

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

	sep_check_tcqe(&dcqe, NULL,
		       (FI_RMA | FI_REMOTE_WRITE | FI_REMOTE_CQ_DATA),
		       WRITE_DATA);
}
예제 #2
0
Test(gnix_cancel, cancel_ep_send)
{
	int ret;
	struct gnix_fid_ep *gnix_ep;
	struct gnix_fab_req *req;
	struct fi_cq_err_entry buf;
	struct gnix_vc *vc;
	void *foobar_ptr = NULL;
	gnix_ht_key_t *key;

	/* simulate a posted request */
	gnix_ep = container_of(ep[0], struct gnix_fid_ep, ep_fid);
	req = _gnix_fr_alloc(gnix_ep);

	req->msg.send_info[0].send_addr = 0xdeadbeef;
	req->msg.cum_send_len = req->msg.send_info[0].send_len = 128;
	req->user_context = foobar_ptr;
	req->type = GNIX_FAB_RQ_SEND;

	/* allocate, store vc */
	ret = _gnix_vc_alloc(gnix_ep, NULL, &vc);
	cr_assert(ret == FI_SUCCESS, "_gnix_vc_alloc failed");

	key = (gnix_ht_key_t *)&gnix_ep->src_addr.gnix_addr;
	ret = _gnix_ht_insert(gnix_ep->vc_ht, *key, vc);
	cr_assert(!ret);

	/* make a dummy request */
	dlist_insert_head(&req->dlist, &vc->tx_queue);

	/* cancel simulated request */
	ret = fi_cancel(&ep[0]->fid, foobar_ptr);
	cr_assert(ret == FI_SUCCESS, "fi_cancel failed");

	/* check for event */
	ret = fi_cq_readerr(msg_cq[0], &buf, FI_SEND);
	cr_assert(ret == 1, "did not find one error event");

	cr_assert(buf.buf == (void *) 0xdeadbeef, "buffer mismatch");
	cr_assert(buf.data == 0, "data mismatch");
	cr_assert(buf.err == FI_ECANCELED, "error code mismatch");
	cr_assert(buf.prov_errno == FI_ECANCELED, "prov error code mismatch");
	cr_assert(buf.len == 128, "length mismatch");
}
예제 #3
0
	CR_API cr_gpu_shader cr_gpu_shader_new( cr_context context, cr_gpu gpu, enum cr_gpu_shader_type type, const char* source, struct cr_gpu_callback on_complete )
	{
		typedef gpu_shader_t::cmd_args args_t;
		cr_assert( CR_COMMAND_ARGS_SIZE >= sizeof( args_t ) );
		
		cr_assert( cr::context::singleton );

		gpu_shader_t* self = new gpu_shader_t( cr_context_get( context ), ( cr::gpu_gl* )gpu );
		self->type = type;

		args_t* args = nullptr;
		cr_command_queue_produce( self->gpu->feeding_queue->cmd_queue, ( cr_command_args* )&args, gpu_shader_t::create );

		args->self = self;
		args->callback = on_complete;

		int len = strlen( source );
		args->source = ( char* )cr_mem_alloc( len );
		memcpy( args->source, source, len );

		return ( cr_gpu_shader )self;
	}
예제 #4
0
void sep_atomic_msg(int index)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
					  (void *) -1, UINT_MAX, UINT_MAX };
	uint64_t min;
	struct fi_msg_atomic msg;
	struct fi_ioc msg_iov;
	struct fi_rma_ioc rma_iov;
	uint64_t w[NUMEPS] = {0}, r[NUMEPS] = {0}, w_e[NUMEPS] = {0};
	uint64_t r_e[NUMEPS] = {0};

	msg_iov.addr = source;
	msg_iov.count = 1;
	msg.msg_iov = &msg_iov;
	msg.desc = (void **)loc_mr;
	msg.iov_count = 1;
	msg.addr = gni_addr[1];
	rma_iov.addr = (uint64_t)target;
	rma_iov.count = 1;
	rma_iov.key = mr_key[1];
	msg.rma_iov = &rma_iov;
	msg.context = target;
	msg.op = FI_MIN;

	/* i32 */
	*((int64_t *)source) = SOURCE_DATA;
	*((int64_t *)target) = TARGET_DATA;
	msg.datatype = FI_INT32;
	sz = fi_atomicmsg(tx_ep[0][index], &msg, 0);
	cr_assert_eq(sz, 0);

	/* reset cqe */
	cqe.op_context = cqe.buf = (void *) -1;
	cqe.flags = cqe.len = cqe.data = cqe.tag = UINT_MAX;
	while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}

	cr_assert_eq(ret, 1);
	sep_check_tcqe(&cqe, target, FI_ATOMIC | FI_WRITE, 0);

	w[0] = 1;
	sep_check_cntrs(w, r, w_e, r_e);
	min = ((int32_t)SOURCE_DATA < (int32_t)TARGET_DATA) ?
		SOURCE_DATA : TARGET_DATA;
	min = (min & U32_MASK) | (TARGET_DATA & (U32_MASK << 32));
	ret = *((int64_t *)target) == min;
	cr_assert(ret, "Data mismatch");
}
예제 #5
0
static enum chitcpd_debug_response check_states(int sockfd, enum chitcpd_debug_event event_flag, debug_socket_state_t *state_info, debug_socket_state_t *saved_state_info, int new_sockfd)
{
    if (event_flag == DBG_EVT_PENDING_CONNECTION)
    {
        return DBG_RESP_ACCEPT_MONITOR;
    }

    if (event_flag == DBG_EVT_TCP_STATE_CHANGE)
    {
        tcp_state_t curs = state_info->tcp_state;

        cr_assert(IS_VALID_TCP_STATE(curs), "Unknown TCP state.");

        if(!saved_state_info)
        {
            cr_assert(curs == SYN_SENT || curs == SYN_RCVD,
                      "%s is not a valid initial state", tcp_str(state_info->tcp_state));
        }
        else
        {
            cr_assert(IS_VALID_TCP_STATE(saved_state_info->tcp_state), "Unknown (previous) TCP state.");
            tcp_state_t prevs = saved_state_info->tcp_state;

            if ( (prevs == SYN_SENT && curs != ESTABLISHED) ||
                    (prevs == SYN_RCVD && curs != ESTABLISHED)  )
                cr_assert_fail("Invalid transition: %s -> %s", tcp_str(prevs), tcp_str(curs));
        }

        chitcpd_debug_save_socket_state(state_info);

        if (curs == ESTABLISHED)
            return DBG_RESP_STOP;
        else
            return DBG_RESP_NONE;
    }

    return DBG_RESP_NONE;
}
예제 #6
0
파일: api.c 프로젝트: agontarek/libfabric
static void rdm_api_teardown_common(bool unreg)
{
	int ret = 0, i = 0;

	free(uc_source);
	free(uc_target);
	free(target);
	free(source);

	for (; i < NUMEPS; i++) {
		fi_close(&recv_cntr[i]->fid);
		fi_close(&send_cntr[i]->fid);

		if (unreg) {
			fi_close(&loc_mr[i]->fid);
			fi_close(&rem_mr[i]->fid);
		}

		ret = fi_close(&ep[i]->fid);
		cr_assert(!ret, "failure in closing ep.");

		ret = fi_close(&msg_cq[i]->fid);
		cr_assert(!ret, "failure in send cq.");

		ret = fi_close(&av[i]->fid);
		cr_assert(!ret, "failure in closing av.");

		ret = fi_close(&dom[i]->fid);
		cr_assert(!ret, "failure in closing domain.");

		fi_freeinfo(fi[i]);
		free(ep_name[i]);
		fi_freeinfo(hints[i]);
	}

	ret = fi_close(&fab->fid);
	cr_assert(!ret, "failure in closing fabric.");
}
예제 #7
0
void do_read_error(int len)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe;
	struct fi_cq_err_entry err_cqe;

	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, -FI_EAVAIL);

	ret = fi_cq_readerr(send_cq, &err_cqe, 0);
	cr_assert_eq(ret, 1);

	cr_assert((uint64_t)err_cqe.op_context == (uint64_t)READ_CTX,
		  "Bad error context");
	cr_assert(err_cqe.flags == (FI_RMA | FI_READ));
	cr_assert(err_cqe.len == 0, "Bad error len");
	cr_assert(err_cqe.buf == 0, "Bad error buf");
	cr_assert(err_cqe.data == 0, "Bad error data");
	cr_assert(err_cqe.tag == 0, "Bad error tag");
	cr_assert(err_cqe.olen == 0, "Bad error olen");
	cr_assert(err_cqe.err == FI_ECANCELED, "Bad error errno");
	cr_assert(err_cqe.prov_errno == GNI_RC_TRANSACTION_ERROR,
		  "Bad prov errno");
	cr_assert(err_cqe.err_data == NULL, "Bad error provider data");

	rdm_rma_check_cntrs(0, 0, 0, 1);
}
예제 #8
0
Test(rdm_sr, send_err)
{
	int ret, max_retrans_val = 0, i = 0; /* 0 to force SMSG failure */

	for (; i < NUMEPS; i++) {
		ret = gni_domain_ops[i]->set_val(&dom[i]->fid,
						 GNI_MAX_RETRANSMITS,
						 &max_retrans_val);
		cr_assert(!ret, "setval(GNI_MAX_RETRANSMITS)");
	}
	rdm_sr_err_inject_enable();

	rdm_sr_xfer_for_each_size(do_send_err, 1, BUF_SZ);
}
예제 #9
0
Test(gnix_hashtable_basic, err_invalid_increase_step_mult)
{
	int ret;
	gnix_hashtable_attr_t attr;

	memcpy(&attr, &default_attr, sizeof(gnix_hashtable_attr_t));

	attr.ht_increase_step = 1;
	attr.ht_increase_type = GNIX_HT_INCREASE_MULT;

	ret = _gnix_ht_init(test_ht, &attr);
	cr_assert(ret == -FI_EINVAL);
	__gnix_hashtable_test_uninitialized();
}
예제 #10
0
Test(gnix_hashtable_advanced, insert_1024)
{
	int ret, i;

	gnix_test_element_t test_elements[1024];

	srand(time(NULL));

	for (i = 0; i < 1024; ++i) {
		test_elements[i].key = i;
		test_elements[i].val = rand() % (1024 * 1024);
		test_elements[i].magic = __GNIX_MAGIC_VALUE;
	}

	for (i = 0; i < 1024; ++i) {
		ret = _gnix_ht_insert(test_ht,
				test_elements[i].key, &test_elements[i]);
		cr_assert(ret == 0);
		cr_assert(atomic_get(&test_ht->ht_elements) == (i + 1));
	}

	cr_assert(atomic_get(&test_ht->ht_elements) == 1024);
}
예제 #11
0
파일: cq.c 프로젝트: agontarek/libfabric
void setup(void)
{
	int ret = 0;

	hints = fi_allocinfo();
	cr_assert(hints, "fi_allocinfo");

	hints->domain_attr->cq_data_size = 4;
	hints->mode = ~0;

	hints->fabric_attr->name = strdup("gni");

	ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
	cr_assert(!ret, "fi_getinfo");

	ret = fi_fabric(fi->fabric_attr, &fab, NULL);
	cr_assert(!ret, "fi_fabric");

	ret = fi_domain(fab, fi, &dom, NULL);
	cr_assert(!ret, "fi_domain");

	cq_attr.wait_obj = FI_WAIT_NONE;
}
예제 #12
0
Test(daemon, startstop)
{
    int rc;
    serverinfo_t *si;

    si = calloc(1, sizeof(serverinfo_t));
    si->server_port = chitcp_htons(GET_CHITCPD_PORT);
    chitcp_unix_socket(si->server_socket_path, UNIX_PATH_MAX);

    rc = chitcpd_server_init(si);
    cr_assert(rc == 0, "Could not initialize chiTCP daemon.");

    rc = chitcpd_server_start(si);
    cr_assert(rc == 0, "Could not start chiTCP daemon.");

    rc = chitcpd_server_stop(si);
    cr_assert(rc == 0, "Could not stop chiTCP daemon.");

    rc = chitcpd_server_wait(si);
    cr_assert(rc == 0, "Waiting for chiTCP daemon failed.");

    chitcpd_server_free(si);
}
예제 #13
0
Test(msg_ack, clone_ack)
{
  AckRecord *t = ack_record_new();
  t->init(t);

  LogMessage *cloned = create_clone(t->original, &t->path_options);

  log_msg_drop(cloned, &t->path_options, AT_PROCESSED);
  cr_assert_not(t->acked);

  t->deinit(t);
  cr_assert(t->acked);
  ack_record_free(t);
}
예제 #14
0
/*
 * Test KAT handler API.
 * The ctx is NULL, expecting failure.
 */
Test(CMAC_API, null_ctx) {
    val = json_parse_file("json/cmac/cmac_aes.json");

    obj = ut_get_obj_from_rsp(val);
    if (!obj) {
        ACVP_LOG_ERR("JSON obj parse error");
        return;
    }

    /* Test with NULL JSON object */
    rv  = acvp_cmac_kat_handler(NULL, obj);
    cr_assert(rv == ACVP_NO_CTX);
    json_value_free(val);
}
예제 #15
0
Test(dg_allocation, dgram_alloc_wc_bnd)
{
	int ret = 0, i;
	struct gnix_cm_nic *cm_nic;
	struct gnix_datagram *dgram_ptr;
	struct gnix_fid_fabric *fab_priv;

	ep_priv = container_of(ep, struct gnix_fid_ep, ep_fid);
	cm_nic = ep_priv->cm_nic;
	cr_assert((cm_nic != NULL), "cm_nic NULL");

	cr_assert((cm_nic->dgram_hndl != NULL), "cm_nic dgram_hndl NULL");

	fab_priv = container_of(fab, struct gnix_fid_fabric, fab_fid);

	for (i = 0; i < fab_priv->n_bnd_dgrams; i++) {
		ret = _gnix_dgram_alloc(cm_nic->dgram_hndl, GNIX_DGRAM_BND,
					&dgram_ptr);
		cr_assert(!ret, "_gnix_dgram_alloc bnd");
		ret = _gnix_dgram_free(dgram_ptr);
		cr_assert(!ret, "_gnix_dgram_free bnd");
	}
}
예제 #16
0
static void
sep_check_cntrs(uint64_t s[], uint64_t r[], uint64_t s_e[],
		uint64_t r_e[])
{
	int i = 0;

	for (; i < NUMEPS; i++) {
		sends[i] += s[i];
		recvs[i] += r[i];
		send_errs[i] += s_e[i];
		recv_errs[i] += r_e[i];

		cr_assert(fi_cntr_read(send_cntr[i]) == sends[i],
			  "Bad send count i:%d send_cntr:%ld sends:%ld",
			  i, fi_cntr_read(send_cntr[i]), sends[i]);
		cr_assert(fi_cntr_read(recv_cntr[i]) == recvs[i],
			  "Bad recv count");
		cr_assert(fi_cntr_readerr(send_cntr[i]) == send_errs[i],
			  "Bad send err count");
		cr_assert(fi_cntr_readerr(recv_cntr[i]) == recv_errs[i],
			  "Bad recv err count");
	}
}
예제 #17
0
void sep_atomic_compwrite(int index)
{
	int ret;
	ssize_t sz;
	struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
					  (void *) -1, UINT_MAX, UINT_MAX };
	uint64_t operand = SOURCE_DATA, op2 = TARGET_DATA;
	uint64_t w[NUMEPS] = {0}, r[NUMEPS] = {0}, w_e[NUMEPS] = {0};
	uint64_t r_e[NUMEPS] = {0};

	/* u64 */
	*((uint64_t *)source) = FETCH_SOURCE_DATA;
	*((uint64_t *)target) = TARGET_DATA;
	sz = fi_compare_atomic(tx_ep[0][index], &operand, 1, NULL, &op2, NULL,
			       source, loc_mr[0], rx_addr[index],
			       (uint64_t)target, mr_key[1], FI_UINT64,
			       FI_CSWAP, target);
	cr_assert_eq(sz, 0, "fi_compare_atomic returned %ld (%s)", sz,
		     fi_strerror(-sz));

	/* reset cqe */
	cqe.op_context = cqe.buf = (void *) -1;
	cqe.flags = cqe.len = cqe.data = cqe.tag = UINT_MAX;
	while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
		pthread_yield();
	}

	cr_assert_eq(ret, 1);
	sep_check_tcqe(&cqe, target, FI_ATOMIC | FI_READ, 0);

	r[0] = 1;
	sep_check_cntrs(w, r, w_e, r_e);
	ret = *((uint64_t *)target) == SOURCE_DATA;
	cr_assert(ret, "Data mismatch");
	ret = *((uint64_t *)source) == TARGET_DATA;
	cr_assert(ret, "Fetch data mismatch");
}
예제 #18
0
/******************************************************************************
* Begin test running routines
******************************************************************************/
void do_getname(void)
{
	int i, ret;
	size_t addrlen;
	void *addr;
	struct gnix_ep_name *src_addr;

	ret = fi_getname(get_fid[ep_type](0), NULL, NULL);
	cr_assert(ret == -FI_EINVAL, "fi_getname returned: %s",
		  fi_strerror(-ret));

	for (i = 0; i < NUMEPS; i++) {
		ret = fi_getname(get_fid[ep_type](i), NULL, &addrlen);
		cr_assert(ret == -FI_ETOOSMALL, "fi_getname returned: %s",
			  fi_strerror(-ret));
		if (use_str_fmt) {
			cr_assert(addrlen == GNIX_FI_ADDR_STR_LEN,
				  "addrlen: %lu does not match size for "
					  "FI_ADDR_STR", addrlen);
		} else {
			cr_assert(addrlen == sizeof(struct gnix_ep_name),
				  "addrlen: %lu does not match the size for"
					  " FI_ADDR_GNI", addrlen);
		}

		addr = malloc(addrlen);
		ret = errno;
		cr_assert_not_null(addr, "malloc returned: %s", strerror(ret));

		ret = fi_getname(get_fid[ep_type](i), addr, &addrlen);
		cr_assert(ret == FI_SUCCESS, "fi_getname returned: %s",
			  fi_strerror(-ret));

		if (use_str_fmt) {
			cr_assert(addrlen == GNIX_FI_ADDR_STR_LEN,
				  "addrlen: %lu does not match size for "
					  "FI_ADDR_STR", addrlen);
		} else {
			cr_assert(addrlen == sizeof(struct gnix_ep_name),
				  "addrlen: %lu does not match the size for "
					  "FI_ADDR_GNI", addrlen);
		}

		get_fid_ep(i, NULL, NULL, (void **) &src_addr);

		dbg_printf(BLUE "ep_name = %p\n" COLOR_RESET, src_addr);

		if (use_str_fmt)
			check_ep_name_str(*src_addr, addr, ep_name_len[i]);
		free(addr);
	}
}
예제 #19
0
void
test_log_messages_can_be_parsed(struct msgparse_params *param)
{
  LogMessage *parsed_message;
  LogStamp *parsed_timestamp;
  time_t now;
  GString *sd_str;

  parsed_message = _parse_log_message(param->msg, param->parse_flags, param->bad_hostname_re);
  parsed_timestamp = &(parsed_message->timestamps[LM_TS_STAMP]);

  if (param->expected_stamp_sec)
    {
      if (param->expected_stamp_sec != 1)
        cr_assert_eq(parsed_timestamp->tv_sec, param->expected_stamp_sec,
                     "Unexpected timestamp, value=%ld, expected=%ld, msg=%s",
                     parsed_timestamp->tv_sec, param->expected_stamp_sec, param->msg);

      cr_assert_eq(parsed_timestamp->tv_usec, param->expected_stamp_usec, "Unexpected microseconds");
      cr_assert_eq(parsed_timestamp->zone_offset, param->expected_stamp_ofs, "Unexpected timezone offset");
    }
  else
    {
      time(&now);
      cr_assert(_absolute_value(parsed_timestamp->tv_sec - now) <= 5,
                "Expected parsed message timestamp to be set to now; now='%d', timestamp->tv_sec='%d'",
                (gint)now, (gint)parsed_timestamp->tv_sec);
    }

  cr_assert_eq(parsed_message->pri, param->expected_pri, "Unexpected message priority");
  assert_log_message_value(parsed_message, LM_V_HOST, param->expected_host);
  assert_log_message_value(parsed_message, LM_V_PROGRAM, param->expected_program);
  assert_log_message_value(parsed_message, LM_V_MESSAGE, param->expected_msg);
  if (param->expected_pid)
    assert_log_message_value(parsed_message, LM_V_PID, param->expected_pid);
  if (param->expected_msgid)
    assert_log_message_value(parsed_message, LM_V_MSGID, param->expected_msgid);
  if (param->expected_sd_str)
    {
      sd_str = g_string_sized_new(0);
      log_msg_format_sdata(parsed_message, sd_str, 0);
      cr_assert_str_eq(sd_str->str, param->expected_sd_str, "Unexpected formatted SData");
      g_string_free(sd_str, TRUE);
    }

  assert_log_message_sdata_pairs(parsed_message, param->expected_sd_pairs);

  log_msg_unref(parsed_message);
}
예제 #20
0
static void setup_dom(enum fi_progress pm)
{
	int ret;

	hints = fi_allocinfo();
	cr_assert(hints, "fi_allocinfo");

	hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
	hints->domain_attr->data_progress = pm;
	hints->domain_attr->cq_data_size = 4;
	hints->mode = mode_bits;

	hints->fabric_attr->prov_name = strdup("gni");

	ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
	cr_assert(!ret, "fi_getinfo");

	ret = fi_fabric(fi->fabric_attr, &fab, NULL);
	cr_assert(!ret, "fi_fabric");

	ret = fi_domain(fab, fi, &dom, NULL);
	cr_assert(!ret, "fi_domain");

}
예제 #21
0
static void fas_getinfo_setup(void)
{
	srand(time(NULL));

	hints = fi_allocinfo();
	cr_assert(hints, "fi_allocinfo");

	hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
	hints->domain_attr->cq_data_size = NUMEPS * 2;
	hints->domain_attr->data_progress = FI_PROGRESS_AUTO;
	hints->domain_attr->control_progress = FI_PROGRESS_AUTO;
	hints->mode = ~0;
	hints->fabric_attr->prov_name = strdup("gni");
	hints->addr_format = use_str_fmt ? FI_ADDR_STR : FI_ADDR_GNI;
}
예제 #22
0
Test(logthrdestdrv, test_explicit_ack_accept)
{
  dd->super.worker.insert = _insert_explicit_acks_message_success;
  dd->super.worker.flush = _flush_explicit_acks_message_success;
  dd->super.batch_lines = 5;

  _generate_messages_and_wait_for_processing(dd, 10, dd->super.written_messages);
  cr_assert(dd->insert_counter == 10, "%d", dd->insert_counter);
  cr_assert(dd->flush_size == 10);

  cr_assert(stats_counter_get(dd->super.processed_messages) == 10);
  cr_assert(stats_counter_get(dd->super.written_messages) == 10);
  cr_assert(stats_counter_get(dd->super.worker.instance.queue->queued_messages) == 0);
  cr_assert(stats_counter_get(dd->super.dropped_messages) == 0);
  cr_assert(stats_counter_get(dd->super.worker.instance.queue->memory_usage) == 0);
  cr_assert(dd->super.shared_seq_num == 11, "%d", dd->super.shared_seq_num);
}
예제 #23
0
Test(logthrdestdrv, batch_timeout_delays_flush_to_the_specified_interval)
{
  /* 3 messages per second, we need to set this explicitly on the queue as it has already been initialized */
  dd->super.worker.insert = _insert_batched_message_success;
  dd->super.worker.flush = _flush_batched_message_success;
  dd->super.batch_lines = 5;
  dd->super.batch_timeout = 1000;

  start_stopwatch();
  _generate_messages(dd, 2);
  gint flush_counter = dd->flush_counter;
  guint64 initial_feed_time = stop_stopwatch_and_get_result();

  /* NOTE: this is a racy check. The rationale that this should be safe:
   *  - we've set batch_timeout to 1 second
   *  - the sending of two messages to the thread shouldn't take this much
   *  - we only assert on the flush counter if this assertion does not fail
   *
   * if we need, we can always increase flush-timeout() if for some reason 1
   * seconds wouldn't be enough time to do this validation.
   */
  cr_assert(initial_feed_time < 1000000,
            "The initial feeding took more than batch_timeout(), e.g. 1 seconds. "
            "We can't validate that no flush happened in this period, check the "
            "comment above this assert for more information. initial_feed_time=%"
            G_GUINT64_FORMAT, initial_feed_time);

  cr_assert(flush_counter == 0,
            "Although the flush time has not yet elapsed, "
            "flush_counter is not zero, flush_counter=%d, initial_feed_time=%"
            G_GUINT64_FORMAT, flush_counter, initial_feed_time);
  _spin_for_counter_value(dd->super.written_messages, 2);

  cr_assert(dd->flush_size == 2);
  cr_assert(dd->flush_counter == 1);
}
예제 #24
0
파일: cntr.c 프로젝트: ddurnov/libfabric
static void do_read_wait(int len)
{
	int i, iters = 10;
	ssize_t sz;
	uint64_t old_w_cnt, new_w_cnt;
	uint64_t old_r_cnt;

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

	old_w_cnt = fi_cntr_read(write_cntr);
	cr_assert(old_w_cnt >= 0);

	old_r_cnt = fi_cntr_read(read_cntr);
	cr_assert(old_r_cnt >= 0);

	for (i = 0; i < iters; i++) {
		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);
	}

	fi_cntr_wait(read_cntr, old_r_cnt + iters, -1);

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

	new_w_cnt = fi_cntr_read(write_cntr);
	cr_assert(new_w_cnt >= 0);

	/*
	 * no fi_read called so old and new read cnts should be equal
	 */
	cr_assert(new_w_cnt == old_w_cnt);
}
예제 #25
0
파일: ep.c 프로젝트: jshimek/libfabric
Test(endpoint_info, info)
{
	int ret;

	hints = fi_allocinfo();
	cr_assert(hints, "fi_allocinfo");

	hints->domain_attr->mr_mode = GNIX_DEFAULT_MR_MODE;
	hints->fabric_attr->prov_name = strdup("gni");

	ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
	cr_assert(!ret, "fi_getinfo");
	cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);
	cr_assert_eq(fi->next->ep_attr->type, FI_EP_DGRAM);
	cr_assert_eq(fi->next->next->ep_attr->type, FI_EP_MSG);
	cr_assert_neq(fi->domain_attr->cntr_cnt, 0);
	cr_assert_neq(fi->domain_attr->cq_cnt, 0);
	cr_assert_eq(fi->domain_attr->ep_cnt, SIZE_MAX);

	fi_freeinfo(fi);

	hints->ep_attr->type = FI_EP_RDM;
	ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
	cr_assert(!ret, "fi_getinfo");
	cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);

	fi_freeinfo(fi);

	hints->ep_attr->type = FI_EP_DGRAM;
	ret = fi_getinfo(fi_version(), NULL, 0, 0, hints, &fi);
	cr_assert(!ret, "fi_getinfo");
	cr_assert_eq(fi->ep_attr->type, FI_EP_DGRAM);

	fi_freeinfo(fi);
	fi_freeinfo(hints);
}
예제 #26
0
void do_inject_write(int len)
{
	ssize_t sz;
	int ret, i, loops = 0;
	struct fi_cq_tagged_entry cqe;

	init_data(source, len, 0x23);
	init_data(target, len, 0);
	sz = fi_inject_write(ep[0], source, len,
			     gni_addr[1], (uint64_t)target, mr_key);
	cr_assert_eq(sz, 0);

	for (i = 0; i < len; i++) {
		loops = 0;
		while (source[i] != target[i]) {
			ret = fi_cq_read(send_cq, &cqe, 1); /* for progress */
			cr_assert(ret == -EAGAIN,
				  "Received unexpected event\n");

			pthread_yield();
			cr_assert(++loops < 10000, "Data mismatch");
		}
	}
}
예제 #27
0
Test(test_pathutils, test_is_file_directory)
{
  int fd = open("test.file", O_CREAT | O_RDWR, 0644);
  cr_assert_not(fd < 0, "open error");
  ssize_t done = write(fd, "a", 1);
  cr_assert_eq(done, 1, "write error");
  int error = close(fd);
  cr_assert_not(error, "close error");

  cr_assert_not(is_file_directory("test.file"), "File is not a directory!");
  cr_assert(is_file_directory("./"), "File is a directory!");

  error = unlink("test.file");
  cr_assert_not(error, "unlink error");
}
예제 #28
0
파일: cntr.c 프로젝트: agontarek/libfabric
Test(cntr_mt, read_wait)
{
	int i, j;
	pthread_t threads[NUM_EPS];
	const int msg_size = 128;
	struct tinfo info = { msg_size, 500 /* iters */};

	cr_assert(NUM_EPS*msg_size <= BUF_SZ);

	memset(source, 0, NUM_EPS*msg_size);
	for (i = 0; i < NUM_EPS; i++) {
		memset(&target[i*msg_size], get_mark(i), msg_size);
	}

	dbg_printf("creating threads\n");
	for (i = 1; i < NUM_EPS; i++) {
		pthread_create(&threads[i], NULL, do_thread_read_wait, &info);
	}

	dbg_printf("joining\n");

	for (i = 1; i < NUM_EPS; i++) {
		pthread_join(threads[i], NULL);
	}

	/* Must wait until all threads are done, since we don't know
	 * which thread got which id */
	for (i = 1; i < NUM_EPS; i++) {
		for (j = 0; j < msg_size; j++) {
			cr_assert(source[i*msg_size+j] == get_mark(i));
		}
	}

	dbg_printf("done\n");

}
예제 #29
0
static void setup_dom(enum fi_progress pm)
{
	int ret;

	hints = fi_allocinfo();
	cr_assert(hints, "fi_allocinfo");

	hints->domain_attr->data_progress = pm;

	hints->domain_attr->cq_data_size = 4;
	hints->mode = ~0;

	hints->fabric_attr->name = strdup("gni");

	ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
	cr_assert(!ret, "fi_getinfo");

	ret = fi_fabric(fi->fabric_attr, &fab, NULL);
	cr_assert(!ret, "fi_fabric");

	ret = fi_domain(fab, fi, &dom, NULL);
	cr_assert(!ret, "fi_domain");

}
예제 #30
0
파일: api.c 프로젝트: agontarek/libfabric
void rdm_api_setup(void)
{
	int i;

	for (i = 0; i < NUMEPS; i++) {
		hints[i] = fi_allocinfo();
		cr_assert(hints[i], "fi_allocinfo");

		hints[i]->domain_attr->cq_data_size = NUMEPS * 2;
		hints[i]->domain_attr->data_progress = FI_PROGRESS_AUTO;
		hints[i]->mode = ~0;
		hints[i]->domain_attr->mr_mode = FI_MR_BASIC;
		hints[i]->fabric_attr->name = strdup("gni");
	}
}