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);
}
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");
}
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;
}
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");
}
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;
}
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.");
}
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);
}
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);
}
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();
}
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);
}
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;
}
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);
}
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);
}
/*
* 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);
}
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");
}
}
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");
}
}
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");
}
/******************************************************************************
* 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);
}
}
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);
}
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");
}
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;
}
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);
}
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);
}
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);
}
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);
}
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");
}
}
}
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");
}
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");
}
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");
}
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");
}
}
