static
unsigned int pscom_openib_rma_mem_register(pscom_con_t *con, pscom_rendezvous_data_t *rd)
{
int err = 0;
pscom_rendezvous_data_openib_t *openib_rd = get_req_data(rd);
psoib_con_info_t *ci = con->arch.openib.mcon;
psoib_rma_mreg_t *mreg = &openib_rd->rma_req.mreg;
if (rd->msg.data_len > IB_MAX_RDMA_MSG_SIZE) goto err_size;
#ifdef IB_RNDV_USE_PADDING
#ifdef IB_RNDV_RDMA_WRITE
#error IB_RNDV_USE_PADDING and IB_RNDV_RDMA_WRITE are mutually exclusive!
#endif
rd->msg.arch.openib.padding_size = (IB_RNDV_PADDING_SIZE - ((long long int)rd->msg.data) % IB_RNDV_PADDING_SIZE) % IB_RNDV_PADDING_SIZE;
memcpy(rd->msg.arch.openib.padding_data, rd->msg.data, rd->msg.arch.openib.padding_size);
/* get mem region */
perf_add("openib_acquire_rma_mreg");
err = psoib_acquire_rma_mreg(mreg, rd->msg.data + rd->msg.arch.openib.padding_size, rd->msg.data_len - rd->msg.arch.openib.padding_size, ci);
assert(!err);
if (err) goto err_get_region;
rd->msg.arch.openib.mr_key = mreg->mem_info.mr->rkey;
rd->msg.arch.openib.mr_addr = (uint64_t)mreg->mem_info.ptr;
return sizeof(rd->msg.arch.openib) - sizeof(rd->msg.arch.openib.padding_data) + rd->msg.arch.openib.padding_size;
#else
/* get mem region */
perf_add("openib_acquire_rma_mreg2");
err = psoib_acquire_rma_mreg(mreg, rd->msg.data, rd->msg.data_len, ci);
assert(!err);
if (err) goto err_get_region;
rd->msg.arch.openib.mr_key = mreg->mem_info.mr->rkey;
rd->msg.arch.openib.mr_addr = (uint64_t)mreg->mem_info.ptr;
return sizeof(rd->msg.arch.openib) - sizeof(rd->msg.arch.openib.padding_data);
#endif
err_get_region:
err_size:
// ToDo: Handle Errors!
return 0;
}
static
int pscom_openib_rma_read(pscom_req_t *rendezvous_req, pscom_rendezvous_data_t *rd)
{
int err, ret;
pscom_rendezvous_data_openib_t *psopenib_rd = get_req_data(rd);
psoib_rma_req_t *dreq = &psopenib_rd->rma_req;
pscom_con_t *con = get_con(rendezvous_req->pub.connection);
psoib_con_info_t *ci = con->arch.openib.mcon;
perf_add("openib_rma_read");
#ifdef IB_RNDV_USE_PADDING
memcpy(rendezvous_req->pub.data, rd->msg.arch.openib.padding_data, rd->msg.arch.openib.padding_size);
rendezvous_req->pub.data += rd->msg.arch.openib.padding_size;
rendezvous_req->pub.data_len -= rd->msg.arch.openib.padding_size;
#endif
err = psoib_acquire_rma_mreg(&dreq->mreg, rendezvous_req->pub.data, rendezvous_req->pub.data_len, ci);
assert(!err); // ToDo: Catch error
dreq->remote_addr = rd->msg.arch.openib.mr_addr;
dreq->remote_key = rd->msg.arch.openib.mr_key;
dreq->data_len = rendezvous_req->pub.data_len;
dreq->ci = ci;
dreq->io_done = pscom_openib_rma_read_io_done;
dreq->priv = psopenib_rd;
psopenib_rd->rendezvous_req = rendezvous_req;
err = psoib_post_rma_get(dreq);
assert(!err); // ToDo: Catch error
return 0;
}
static
void pscom_openib_do_write(pscom_con_t *con)
{
size_t len;
struct iovec iov[2];
pscom_req_t *req;
req = pscom_write_get_iov(con, iov);
if (req) {
psoib_con_info_t *mcon = con->arch.openib.mcon;
len = iov[0].iov_len + iov[1].iov_len;
perf_add("openib_sendv");
ssize_t rlen = psoib_sendv(mcon, iov, len);
if (rlen >= 0) {
pscom_write_done(con, req, rlen);
pscom_check_cq_poll();
} else if ((rlen == -EINTR) || (rlen == -EAGAIN)) {
// Busy: Maybe out of tokens? try to read more tokens:
_pscom_openib_do_read(con, mcon);
} else {
// Error
pscom_con_error(con, PSCOM_OP_WRITE, PSCOM_ERR_STDERROR);
}
}
}
static
void pscom_openib_rma_mem_deregister(pscom_con_t *con, pscom_rendezvous_data_t *rd)
{
pscom_rendezvous_data_openib_t *openib_rd = get_req_data(rd);
psoib_rma_mreg_t *mreg = &openib_rd->rma_req.mreg;
perf_add("openib_release_rma_mreg");
psoib_release_rma_mreg(mreg);
}
static
int pscom_openib_rma_write(pscom_con_t *con, void *src, pscom_rendezvous_msg_t *des,
void (*io_done)(void *priv), void *priv)
{
pscom_rendezvous_data_t *rd_data = (pscom_rendezvous_data_t *)pscom_malloc(sizeof(*rd_data));
pscom_rendezvous_data_openib_t *rd_data_openib = get_req_data(rd_data);
psoib_con_info_t *mcon = con->arch.openib.mcon;
psoib_rma_req_t *dreq = &rd_data_openib->rma_req;
size_t len;
int err;
rd_data->msg.id = (void*)42;
rd_data->msg.data = src;
rd_data->msg.data_len = des->data_len;
len = pscom_openib_rma_mem_register(con, rd_data);
assert(len); // ToDo: Catch error
/*
dreq->mreg.mem_info.ptr = xxx;
dreq->mreg.size = xxx;
dreq->mreg.mem_ingo.mr->lkey = xxx;
*/
perf_add("openib_rma_write");
dreq->remote_addr = des->arch.openib.mr_addr;
dreq->remote_key = des->arch.openib.mr_key;
dreq->data_len = des->data_len;
dreq->ci = mcon;
dreq->io_done = pscom_openib_rma_write_io_done;
dreq->priv = rd_data;
rd_data_openib->con = con;
rd_data_openib->io_done = io_done;
rd_data_openib->priv = priv;
err = psoib_post_rma_put(dreq);
assert(!err); // ToDo: Catch error
rd_data = NULL; /* Do not use rd_data after psoib_post_rma_put()!
io_done might already be called and freed rd_data. */
return 0;
}
static
int _pscom_openib_do_read(pscom_con_t *con, psoib_con_info_t *mcon)
{
void *buf;
ssize_t size;
size = psoib_recvlook(mcon, &buf);
if (size >= 0) {
perf_add("openib_do_read");
pscom_read_done(con, buf, size);
psoib_recvdone(mcon);
return 1;
} else if ((size == -EINTR) || (size == -EAGAIN)) {
// Nothing received
return 0;
} else {
// Error
errno = -size;
pscom_con_error(con, PSCOM_OP_READ, PSCOM_ERR_STDERROR);
return 1;
}
}
gboolean mouse_clicked(GtkWidget *widget, GdkEventButton *event)
{
// Handle click event on canvas
int index;
double coordx, coordy;
select_t *select = NULL;
// Length from click location to nearest dot
mouse_discarded = 0;
if (event->button == 8)
{
// back button
if (event->state == GDK_SHIFT_MASK)
set_prev_count();
else if (event->state == GDK_CONTROL_MASK)
set_first();
else
set_prev();
fldstate.mouse_clicked = 0x0;
}
else if (event->button == 9)
{
// forward button
if (event->state == GDK_SHIFT_MASK)
set_next_count();
else if (event->state == GDK_CONTROL_MASK)
set_last();
else
set_next();
fldstate.mouse_clicked = 0x0;
}
else if (event->button == 1)
{
fldstate.mouse_clicked = 0x1;
mouse_clickx = event->x;
mouse_clicky = event->y;
pixel_to_field(&mouse_clickx, &mouse_clicky);
fldstate.mouse_clickx = mouse_clickx;
fldstate.mouse_clicky = mouse_clicky;
switch(mouse_currentMode)
{
case SELECTONE:
// select 1 performer
select = field_get_in_area(mouse_clickx, mouse_clicky);
if (event->state == GDK_CONTROL_MASK)
{
// ctrl-click
select_toggle_multiple(pstate.select, select);
}
else if ((event->state & ~GDK_SHIFT_MASK)== 0)
{
// regular click
if (select_empty(select))
{
//select_dots_discard();
select_clear(pstate.select);
mouse_discarded = 1;
break;
}
index = select_get_form(select);
if (!select_form_empty(select) && !select_check_form(pstate.select, index))
{
// select form with ability to scale form
select_clear(pstate.select);
mouse_discarded = 1;
select_add_form(pstate.select, select_get_form(select));
select_update_center(pstate.select);
}
else if (select_form_empty(select) && isSelected(select_get_dot(select)) != 1)
{
// dot is not selected
select_clear(pstate.select);
mouse_discarded = 1;
if ((index = select_get_dot(select))!= -1)
{
select_add_dot(pstate.select, index);
}
}
else
{
// hold click; dots being moved
fldstate.mouse_clicked |= 0x2;
}
}
dr_canvas_refresh(drill);
break;
case ADDPERF:
// Add performers by clicking on canvas
coordx = event->x;
coordy = event->y;
pixel_to_field(&coordx, &coordy);
index = perf_add();
//coords_set_coord(pshow, index, coordx, coordy);
coords_set(pshow->sets->currset->coords[index], coordx, coordy);
dr_canvas_refresh(drill);
break;
case ADDFORM:
break;
}
}
else
fldstate.mouse_clicked = 0;
return TRUE;
}
int
main(int argc, char **argv)
{
krb5_context context;
krb5_error_code ret;
int optidx = 0;
setprogname(argv[0]);
if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &optidx))
usage(1);
if (help_flag)
usage (0);
if(version_flag){
print_version(NULL);
exit(0);
}
argc -= optidx;
argv += optidx;
if (argc != 0)
errx(1, "argc != 0");
ret = krb5_init_context(&context);
if (ret)
errx (1, "krb5_init_context failed: %d", ret);
if (perf_str) {
krb5_keytab id;
ret = krb5_kt_resolve(context, perf_str, &id);
if (ret)
krb5_err(context, 1, ret, "krb5_kt_resolve: %s", perf_str);
/* add, find, delete on keytab */
perf_add(context, id, times);
perf_find(context, id, times);
perf_delete(context, id, 0, times);
/* add and find again on used keytab */
perf_add(context, id, times);
perf_find(context, id, times);
ret = krb5_kt_destroy(context, id);
if (ret)
krb5_err(context, 1, ret, "krb5_kt_destroy: %s", perf_str);
ret = krb5_kt_resolve(context, perf_str, &id);
if (ret)
krb5_err(context, 1, ret, "krb5_kt_resolve: %s", perf_str);
/* try delete backwards */
#if 0
perf_add(context, id, times);
perf_delete(context, id, 1, times);
#endif
ret = krb5_kt_destroy(context, id);
if (ret)
krb5_err(context, 1, ret, "krb5_kt_destroy");
} else {
test_empty_keytab(context, "MEMORY:foo");
test_empty_keytab(context, "FILE:foo");
test_memory_keytab(context, "MEMORY:foo", "MEMORY:foo2");
}
krb5_free_context(context);
return 0;
}
