int main(int argc, char** argv)
{
puts("TEST BEGIN!\n");
int ret;
task_t tasks[1];
tasks[0].lambda = fun1;
tasks[0].data = (void*)'@';
tasks[0].stack_pos = (void*)0xa2000000;
tasks[0].C = 1;
tasks[0].T = PERIOD_DEV0;
// this should fail and return EINVAL
ret = task_create(tasks, 65);
check_return(errno,EINVAL,"1. Test create return EINVAL");
// this should return EFAULT
ret = task_create((task_t *)0xdeadbeef, 30);
check_return(errno,EFAULT,"2. Test create return EFAULT");
ret = task_create(tasks, 1);
puts("TEST END!\n");
argc = argc;
argv = argv;
return 0;
}
void shoot() {
const uint8_t * const myrgb[4]={buffer,0,0,0};
int mylinesize[4]={c->width*4,0,0,0};
/* color convert picture */
sws_scale(img_convert_ctx, (uint8_t**)myrgb, mylinesize,
0, c->height, picture->data, picture->linesize);
/* encode the image */
//int out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
int got_packet=0;
av_init_packet(&pkt);
int ret = avcodec_encode_video2(c, &pkt, picture, &got_packet);
check_return(ret, "Error encoding video frame");
/* if no packet, it means the image was buffered */
if (got_packet) {
/* write the compressed frame in the media file */
pkt.pts = pkt.dts = picture->pts = AV_NOPTS_VALUE; // Somehow necessary to fix the fps.
pkt.stream_index= video_st->index;
ret = av_interleaved_write_frame(oc, &pkt);
check_return(ret, "Error while writing video frame");
}
//printf("capture.cpp: Written frame %d, size=%d\n",frame_count, out_size);
frame_count++;
}
static inline void poll_events (void)
{
int ret;
cci_event_t *event;
ret = cci_get_event (endpoint, &event);
if (ret == CCI_SUCCESS) {
assert (event);
switch (event->type) {
case CCI_EVENT_CONNECT_REQUEST:
opts = *((options_t *) event->request.data_ptr);
ret = cci_reject (event);
check_return (ctl_ep, "reject", ret, 1);
break;
case CCI_EVENT_CONNECT:
if (!is_server) {
connection = event->accept.connection;
if (event->connect.status == CCI_ECONNREFUSED) {
printf ("Connection refused\n");
ret = cci_send (ctl_conn, "bye", 5, (void*)0xdeadbeef, ctl_opts.flags);
check_return(ctl_ep, "cci_send", ret, 0);
done = 1;
}
}
break;
default:
fprintf (stderr, "ignoring event type %d\n",
event->type);
}
}
return;
}
void flush() {
for(;;) {
int got_packet=0;
av_init_packet(&pkt);
int ret = avcodec_encode_video2(c, &pkt, nullptr, &got_packet);
check_return(ret, "Error encoding video frame");
if (!got_packet) break;
/* write the compressed frame in the media file */
pkt.pts = pkt.dts = picture->pts = AV_NOPTS_VALUE; // Somehow necessary to fix the fps.
pkt.stream_index= video_st->index;
ret = av_interleaved_write_frame(oc, &pkt);
check_return(ret, "Error while writing video frame");
}
}
void fun1(void* str)
{
int ret2,i,ind;
str = str;
for(i=0 ;i<MAX_MUTEX;i++) {
ind = mutex_create();
}
ret2 = mutex_create();
check_return(errno,ENOMEM,"3. Mutex Create returns ENOMEM");
ret2 = mutex_unlock(165);
check_return(errno,EINVAL,"4. Mutex Unlock return EINVAL");
ret2 = mutex_unlock(23);
check_return(errno,EPERM,"5. Mutex Unlock return EPERM");
ret2 = mutex_lock(124);
check_return(errno,EINVAL,"6. Mutex Lock return EINVAL");
ret2 = mutex_lock(4);
check_return(ret2,0,"7. Mutex Lock return success");
ret2 = mutex_lock(4);
check_return(errno,EDEADLOCK,"8. Mutex Lock return EDEADLOCK");
ret2 = mutex_unlock(4);
check_return(ret2,0,"9. Mutex Unlock return success");
ret2 = event_wait(10000);
check_return(errno,EINVAL,"10. Event Wait return EINVAL");
puts("TEST END!\n");
while(1) {
spin++;
}
}
static void
accept_connection(void)
{
send_uri();
while (!connection) {
int ret = 0;
cci_event_t *event = NULL;
ret = cci_get_event(endpoint, &event);
if (ret == CCI_SUCCESS) {
switch (event->type) {
case CCI_EVENT_CONNECT_REQUEST:
opts = *((options_t *) event->request.data_ptr);
cci_accept(event, NULL);
break;
case CCI_EVENT_ACCEPT:
assert(event->accept.status == CCI_SUCCESS);
connection = event->accept.connection;
ret = posix_memalign((void **)&buffer, 4096,
opts.transfer_size);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 'a', opts.transfer_size);
ret = posix_memalign((void **)&ack, 4096, opts.ack_size);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 'b', opts.ack_size);
ret = cci_rma_register(endpoint,
buffer,
opts.transfer_size,
CCI_FLAG_WRITE|CCI_FLAG_READ,
&local);
check_return(endpoint, "cci_rma_register",
ret, 1);
remote = &opts.rma_handle;
break;
default:
fprintf(stderr, "%s: got %s event\n", __func__,
cci_event_type_str(event->type));
}
cci_return_event(event);
}
}
return;
}
void fg_bg(t_jobs *jobs, char **tab, int k)
{
int pid;
int ret;
ret = 0;
pid = 0;
if (jobs == NULL)
{
job_error(k);
return ;
}
if (tab[1])
{
if (is_digit(tab[1]) == 0)
{
pid_error(tab[1]);
return ;
}
}
else
pid = find_pid(g_jobs);
job_continued(jobs->job, jobs->name);
kill(pid, SIGCONT);
waitpid(pid, &ret, WUNTRACED);
check_return(ret, pid);
}
BUF_MEM *
PACE_STEP3A_generate_mapping_data(const EAC_CTX * ctx)
{
check_return((ctx && ctx->pace_ctx && ctx->pace_ctx->map_generate_key), "Invalid arguments");
return ctx->pace_ctx->map_generate_key(ctx->pace_ctx, ctx->bn_ctx);
}
static void
connect_to_server(void) {
int ret = 0;
cci_conn_attribute_t attr = CCI_CONN_ATTR_RO;
recv_uri();
again:
ret = cci_connect(endpoint, server_uri, &opts, sizeof(opts),
attr, NULL, 0, NULL);
check_return(endpoint, "cci_connect", ret, 1);
while (!connection) {
cci_event_t *event = NULL;
ret = cci_get_event(endpoint, &event);
if (ret == CCI_SUCCESS) {
assert(event->type == CCI_EVENT_CONNECT);
connection = event->connect.connection;
if (!connection) {
cci_return_event(event);
fprintf(stderr, "Connecting to %s failed\n", server_uri);
attempt *= 2;
sleep(attempt);
goto again;
}
cci_return_event(event);
}
}
return;
}
BUF_MEM *
dh_gm_generate_key(const PACE_CTX * ctx, BN_CTX *bn_ctx)
{
check_return(ctx, "Invalid arguments");
return dh_generate_key(ctx->static_key, bn_ctx);
}
BUF_MEM *
ecdh_im_generate_key(const PACE_CTX * ctx, BN_CTX *bn_ctx)
{
check_return((ctx && ctx->ka_ctx), "Invalid arguments");
return randb(EVP_CIPHER_key_length(ctx->ka_ctx->cipher));
}
BUF_MEM *
kdf_mac(const BUF_MEM *nonce, const KA_CTX *ctx, EVP_MD_CTX *md_ctx)
{
check_return(ctx, "Invalid arguments");
return kdf(ctx->shared_secret, nonce, htonl(KDF_MAC_COUNTER), ctx, md_ctx);
}
BUF_MEM *
CA_STEP2_get_eph_pubkey(const EAC_CTX *ctx)
{
check_return(ctx && ctx->ca_ctx && ctx->ca_ctx->ka_ctx,
"Invalid arguments");
return get_pubkey(ctx->ca_ctx->ka_ctx->key, ctx->bn_ctx);
}
BUF_MEM *
CA_STEP1_get_pubkey(const EAC_CTX *ctx)
{
check_return(ctx && ctx->ca_ctx && ctx->ca_ctx->ka_ctx,
"Invalid arguments");
return asn1_pubkey(ctx->ca_ctx->protocol, ctx->ca_ctx->ka_ctx->key,
ctx->bn_ctx, ctx->tr_version);
}
BUF_MEM *
get_pubkey(EVP_PKEY *key, BN_CTX *bn_ctx)
{
BUF_MEM *out;
DH *dh;
EC_KEY *ec;
const EC_POINT *ec_pub;
const BIGNUM *dh_pub_key;
check_return(key, "invalid arguments");
switch (EVP_PKEY_base_id(key)) {
case EVP_PKEY_DH:
dh = EVP_PKEY_get1_DH(key);
check_return(dh, "no DH key");
DH_get0_key(dh, &dh_pub_key, NULL);
out = BN_bn2buf(dh_pub_key);
DH_free(dh);
break;
case EVP_PKEY_EC:
ec = EVP_PKEY_get1_EC_KEY(key);
check_return(ec, "no EC key");
ec_pub = EC_KEY_get0_public_key(ec);
check_return(ec_pub, "no EC public key");
out = EC_POINT_point2mem(ec, bn_ctx, ec_pub);
EC_KEY_free(ec);
break;
default:
log_err("unknown type of key");
return NULL;
}
return out;
}
static void
date_test_fmt(date d, char *fmt)
{
static int i;
char buf[200];
int r;
r = rfmtdate(d, fmt, buf);
printf("r: %d ", r);
if (r != 0)
check_return(r);
else
printf("date: %d: %s\n", i++, buf);
}
static int
transfer_data(int cookie)
{
int ret = 0;
assert(is_server);
ret = cci_rma(connection, ack, opts.ack_size, local, 0,
remote, 0, opts.transfer_size,
(void*)((uintptr_t)cookie), opts.rma_flags);
check_return(endpoint, "cci_rma", ret, 0);
return ret;
}
BUF_MEM *
PACE_STEP3B_generate_ephemeral_key(EAC_CTX * ctx)
{
check_return((ctx && ctx->pace_ctx), "Invalid arguments");
ctx->pace_ctx->my_eph_pubkey = KA_CTX_generate_key(ctx->pace_ctx->ka_ctx,
ctx->bn_ctx);
if (!ctx->pace_ctx->my_eph_pubkey)
return NULL;
return BUF_MEM_create_init(ctx->pace_ctx->my_eph_pubkey->data,
ctx->pace_ctx->my_eph_pubkey->length);
}
static int
send_request(int cnt)
{
int ret = 0;
assert(!is_server);
/* Send the count in the request */
*msg = cnt;
ret = cci_send(connection, request, opts.req_size, (void*)((uintptr_t)cnt), 0);
check_return(endpoint, "cci_send", ret, 0);
return ret;
}
int check_statement(ast::abstract::Statement* statement) {
assert(statement != nullptr);
switch(*statement) {
case ast::ReturnNode:
return check_return(dynamic_cast<ast::Return*>(statement));
break;
case ast::BranchNode:
return check_branch(dynamic_cast<ast::Branch*>(statement));
break;
case ast::AssignmentNode:
return check_assignment(dynamic_cast<ast::Assignment*>(statement));
break;
case ast::WhileNode:
return check_while(dynamic_cast<ast::While*>(statement));
break;
case ast::VoidContextNode:
return check_void_context(dynamic_cast<ast::VoidContext*>(statement));
break;
}
assert(false);
return EXIT_SUCCESS;
}
static void do_server(void)
{
int ret = 0, i = 0;
accept_connection();
if (connection->max_send_size < opts.ack_size)
opts.ack_size = connection->max_send_size;
while (!done)
progress_server();
for (i = 0; i < 1000; i++)
progress_server();
ret = cci_rma_deregister(endpoint, local);
check_return(endpoint, "cci_rma_deregister", ret, 1);
if (!suppress)
printf("server done\n");
return;
}
static void
date_test_strdate(char *input)
{
static int i;
date d;
int r, q;
char dbuf[11];
r = rstrdate(input, &d);
printf("r: %d ", r);
if (r == 0)
{
q = rdatestr(d, dbuf);
printf("q: %d ", q);
if (q == 0)
{
printf("date %d: %s\n", i++, dbuf);
}
else
printf("\n");
}
else
check_return(r);
}
static void
date_test_defmt(char *fmt, char *input)
{
static int i;
char dbuf[11];
date d;
int q, r;
r = rdefmtdate(&d, fmt, input);
printf("r: %d ", r);
if (r == 0)
{
q = rdatestr(d, dbuf);
printf("q: %d ", q);
if (q == 0)
{
printf("date %d: %s\n", i++, dbuf);
}
else
printf("\n");
}
else
check_return(r);
}
static inline void do_client (void)
{
int ret;
ret = cci_connect (ctl_ep, server_uri, &ctl_opts, sizeof (ctl_opts), attr,
NULL, 0, NULL);
check_return (ctl_ep, "cci_connect", ret, 1);
while (!done) {
poll_ctl_events ();
if (endpoint != NULL)
poll_events();
}
if (connection == NULL) {
fprintf (stderr, "Connection Rejected -- Test Successful\n");
} else {
fprintf (stderr, "Connection Accepted -- Test fails\n");
}
sleep (1);
return;
}
static void do_client(void)
{
int ret;
uint32_t min = 0, max;
struct timeval start, end;
char *func;
char *header = "Done";
/* initiate connect */
ret =
cci_connect(endpoint, server_uri, &opts, sizeof(opts), attr, NULL,
0, NULL);
check_return(endpoint, "cci_connect", ret, 1);
/* poll for connect completion */
while (!connect_done)
poll_events();
if (!connection) {
fprintf(stderr, "no connection\n");
return;
}
while (!ready)
poll_events();
if (opts.method == MSGS) {
func = "cci_send";
max = connection->max_send_size;
} else {
func = "cci_rma";
max = opts.max_rma_size;
}
ret = posix_memalign((void **)&buffer, 4096, max);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 'b', max);
if (opts.method != MSGS) {
int flags = 0;
/* for the client, we want the opposite of the opts.method.
* when testing RMA WRITE, we only need READ access.
* when testing RMA READ, we need WRITE access.
*/
if (opts.method == RMA_WRITE)
flags = CCI_FLAG_READ;
else if (opts.method == RMA_READ)
flags = CCI_FLAG_WRITE;
ret = cci_rma_register(endpoint, buffer, max, flags,
&local_rma_handle);
check_return(endpoint, "cci_rma_register", ret, 1);
fprintf(stderr, "local_rma_handle is %p\n",
(void*)local_rma_handle);
min = 1;
if (opts.method == RMA_WRITE)
opts.flags |= CCI_FLAG_WRITE;
else
opts.flags |= CCI_FLAG_READ;
}
if (remote_completion) {
rmt_comp_msg = header;
rmt_comp_len = 4;
}
if (opts.method == MSGS)
printf("Bytes\t\tLatency (one-way)\tThroughput\n");
else
printf("Bytes\t\tLatency (round-trip)\tThroughput\n");
/* begin communication with server */
for (current_size = min; current_size <= max;) {
double lat = 0.0;
double bw = 0.0;
if (opts.method == MSGS)
ret =
cci_send(connection, buffer, current_size, NULL,
opts.flags);
else
ret = cci_rma(connection, rmt_comp_msg, rmt_comp_len,
local_rma_handle, 0,
&opts.rma_handle, 0,
current_size, (void *)1, opts.flags);
check_return(endpoint, func, ret, 1);
while (count < warmup)
poll_events();
gettimeofday(&start, NULL);
while (count < warmup + iters)
poll_events();
gettimeofday(&end, NULL);
if (opts.method == MSGS)
lat = usecs(start, end) / (double)iters / 2.0;
else
lat = usecs(start, end) / (double)iters;
bw = (double)current_size / lat;
printf("%8d\t%8.2f us\t\t%8.2f MB/s\n", current_size, lat,
bw);
count = 0;
if (current_size == 0)
current_size++;
else
current_size *= 2;
if (current_size >= 64 * 1024) {
if (iters >= 32)
iters /= 2;
if (warmup >= 4)
warmup /= 2;
}
}
ret = cci_send(connection, "bye", 3, (void *)0xdeadbeef, opts.flags);
check_return(endpoint, "cci_send", ret, 0);
while (!done)
poll_events();
if (opts.method != MSGS) {
ret = cci_rma_deregister(endpoint, local_rma_handle);
check_return(endpoint, "cci_rma_deregister", ret, 1);
}
printf("client done\n");
sleep(1);
return;
}
static void do_client(void)
{
int ret, i = 0;
struct timeval start, end;
double lat = 0.0;
double bw = 0.0;
ret = posix_memalign((void **)&request, 4096, opts.req_size);
check_return(endpoint, "memalign buffer", ret, 1);
msg = (int*) request;
ret = posix_memalign((void **)&buffer, 4096, opts.transfer_size);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 'b', opts.transfer_size);
ret = cci_rma_register(endpoint, buffer, opts.transfer_size,
opts.rma_flags, &local);
check_return(endpoint, "cci_rma_register", ret, 1);
memcpy(&opts.rma_handle, local, sizeof(*local));
connect_to_server();
if (connection->max_send_size < opts.req_size)
opts.req_size = connection->max_send_size;
if (!suppress)
printf("Bytes\t\tLatency (per rpc)\tThroughput (per rpc)\n");
/* begin communication with server */
ret = send_request(count);
check_return(endpoint, "send first request", ret, 1);
if (!ret) {
count++;
inflight++;
}
progress_client(opts.warmup);
count = 0;
completed = 0;
gettimeofday(&start, NULL);
for (i = 0; i < concurrent; i++) {
ret = send_request(count);
if (!ret) {
count++;
inflight++;
}
check_return(endpoint, "send first request", ret, 0);
}
progress_client(opts.iters);
gettimeofday(&end, NULL);
lat = usecs(start, end) / (double)opts.iters;
bw = (double)opts.transfer_size / lat;
printf("%8d\t%8.2f us\t\t%8.2f MB/s\n", opts.transfer_size, lat, bw);
ret = cci_send(connection, "bye", 3, (void *)0xdeadbeef, 0);
check_return(endpoint, "cci_send", ret, 1);
progress_client(0);
ret = cci_rma_deregister(endpoint, local);
check_return(endpoint, "cci_rma_deregister", ret, 1);
if (!suppress)
printf("client done\n");
return;
}
int main(int argc, char *argv[])
{
int c, ret;
int dereg = 0, prefault = 0;
uint32_t pagesize = 0, offset = 0;
uint64_t regsize = REGSIZE, totalsize = TOTALSIZE, count, i;
uint32_t caps;
cci_device_t * const *devices;
cci_endpoint_t *endpoint;
void *base, *ptr;
uint64_t length;
cci_rma_handle_t **handles = NULL;
struct timeval start, end;
uint64_t usecs = 0;
pagesize = sysconf(_SC_PAGESIZE);
while ((c = getopt(argc, argv, "dfo:s:t:")) != -1) {
switch (c) {
case 'd':
dereg = 1;
break;
case 'f':
prefault = 1;
break;
case 'o':
offset = strtoul(optarg, NULL, 0);
if (offset >= pagesize) {
fprintf(stderr,
"offset larger than pagesize (%u)\n",
pagesize);
usage(argv[0]);
}
break;
case 's':
regsize = strtoull(optarg, NULL, 0);
if (regsize < pagesize) {
printf("regsize (%" PRIu64
") < pagesize (%u) - increasing to pagesize\n",
regsize, pagesize);
regsize = pagesize;
}
break;
case 't':
totalsize = strtoull(optarg, NULL, 0);
break;
default:
usage(argv[0]);
break;
}
}
count = totalsize / regsize;
ret = posix_memalign(&base, pagesize, totalsize + offset);
check_return(NULL, "posix_memalign", ret);
ptr = (void*)((uintptr_t)base + (uintptr_t) offset);
length = regsize;
handles = calloc(count, sizeof(*handles));
check_return(NULL, "calloc", handles ? 0 : CCI_ENOMEM);
if (prefault) {
for (i = 0; i < totalsize; i += pagesize) {
char *c = (char *)ptr + (uintptr_t) i;
*c = '1';
}
}
ret = cci_init(CCI_ABI_VERSION, 0, &caps);
check_return(NULL, "cci_init", ret);
ret = cci_get_devices(&devices);
check_return(NULL, "cci_get_devices", ret);
ret = cci_create_endpoint(NULL, 0, &endpoint, NULL);
check_return(NULL, "cci_create_endpoint", ret);
/* register */
if (!dereg)
gettimeofday(&start, NULL);
for (i = 0; i < count; i++) {
void *p = (void*)((uintptr_t)ptr + ((uintptr_t) i * (uintptr_t)length));
ret = cci_rma_register(endpoint, p, length, CCI_FLAG_READ|CCI_FLAG_WRITE, &handles[i]);
check_return(endpoint, "cci_rma_register", ret);
}
if (!dereg)
gettimeofday(&end, NULL);
/* deregister */
if (dereg)
gettimeofday(&start, NULL);
for (i = 0; i < count; i++) {
ret = cci_rma_deregister(endpoint, handles[i]);
check_return(endpoint, "cci_rma_register", ret);
}
if (dereg)
gettimeofday(&end, NULL);
usecs = (end.tv_sec - start.tv_sec) * 1000000 +
end.tv_usec - start.tv_usec;
printf("%10s%10s%10s%10s\n", "RegSize", "Count", "usecs", "us/page");
printf("%10" PRIu64 "%10" PRIu64 "%10" PRIu64 "%10.2f\n",
regsize, count, usecs,
((double)usecs / (double) count) / ((double)regsize / (double)pagesize));
ret = cci_destroy_endpoint(endpoint);
check_return(endpoint, "cci_destroy_endpoint", ret);
ret = cci_finalize();
check_return(NULL, "cci_finalize", ret);
return 0;
}
int check_stmt(is_stmt* node)
{
int errors = 0;
/* ; empty statement */
if (!node)
return 0;
switch (node->type)
{
case t_stmt_stmt_list:
node->data.stmt_list.scope = scope_new(NULL, false);
scope_push(node->data.stmt_list.scope);
errors += check_stmt_list(node->data.stmt_list.list);
scope_pop();
if (errors == 0)
node->terminates = node->data.stmt_list.list->terminated;
break;
case t_stmt_var_stmt:
errors += check_var_stmt(node->data.var, false);
break;
case t_stmt_assign:
errors += check_assign_op(node->data.assign);
break;
case t_stmt_incr:
errors += check_incr_op(node->data.incr);
break;
case t_stmt_if:
errors += check_if(node->data.if_stmt);
if (errors == 0)
node->terminates = node->data.if_stmt->terminates;
break;
case t_stmt_loop:
errors += check_loop_stmt(node->data.loop);
if (errors == 0)
node->terminates = node->data.loop->terminates;
break;
case t_stmt_func_call:
errors += check_func_call(node->data.func_call);
break;
case t_stmt_switch:
errors += check_switch(node->data.switch_stmt);
if (errors == 0)
node->terminates = node->data.switch_stmt->terminates;
break;
case t_stmt_break:
errors += check_break(node->data.break_stmt);
node->terminates = true;
break;
case t_stmt_continue:
errors += check_continue(node->data.continue_stmt);
node->terminates = true;
break;
case t_stmt_return:
errors += check_return(node->data.return_stmt);
node->terminates = true;
break;
}
return errors;
}
int main(int argc, char *argv[])
{
int ret, c;
uint32_t caps = 0;
char *transport = NULL;
cci_device_t * const *devices = NULL, *device = NULL;
name = argv[0];
opts.iters = ITERS;
opts.warmup = WARMUP;
opts.req_size = REQ_SIZE;
opts.transfer_size = TRANSFER_SIZE;
opts.ack_size = ACK_SIZE;
while ((c = getopt(argc, argv, "h:st:i:W:c:wrR:T:A:S")) != -1) {
switch (c) {
case 'h':
strncpy(server_uri, optarg, sizeof(server_uri));
break;
case 's':
is_server = 1;
break;
case 't':
transport = strdup(optarg);
break;
case 'i':
opts.iters = strtoul(optarg, NULL, 0);
break;
case 'W':
opts.warmup = strtoul(optarg, NULL, 0);
break;
case 'c':
concurrent = strtoul(optarg, NULL, 0);
if (concurrent > 64)
concurrent = 64;
break;
case 'w':
/* The client wants to write. The server will RMA Read. */
opts.rma_flags = CCI_FLAG_READ;
break;
case 'r':
/* The client wants to read. The server will RMA Write. */
opts.rma_flags = CCI_FLAG_WRITE;
break;
case 'R':
opts.req_size = strtoul(optarg, NULL, 0);
if (opts.req_size > REQ_SIZE)
opts.req_size = REQ_SIZE;
break;
case 'T':
opts.transfer_size = strtoul(optarg, NULL, 0);
break;
case 'A':
opts.ack_size = strtoul(optarg, NULL, 0);
if (opts.ack_size > ACK_SIZE)
opts.ack_size = ACK_SIZE;
break;
case 'S':
suppress = 1;
break;
default:
print_usage();
}
}
if (!opts.rma_flags)
opts.rma_flags = CCI_FLAG_READ;
if (!opts.transfer_size)
opts.transfer_size = TRANSFER_SIZE;
#ifndef USE_MPI
if (!is_server && server_uri[0] == '\0') {
fprintf(stderr, "Must select -h or -s\n");
print_usage();
}
#else
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (rank == 0)
is_server = 1;
#endif
ret = cci_init(CCI_ABI_VERSION, 0, &caps);
check_return(NULL, "cci_init", ret, 1);
if (transport) {
int i = 0;
ret = cci_get_devices(&devices);
check_return(NULL, "cci_get_devices", ret, 1);
/* Select first device that matches transport. */
for (i = 0; ; i++) {
device = devices[i];
if (!device)
break;
if (strncmp(device->transport, transport, strlen(device->transport)) == 0)
break;
}
}
/* create an endpoint */
ret = cci_create_endpoint(device, 0, &endpoint, NULL);
check_return(NULL, "cci_create_endpoint", ret, 1);
ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri);
check_return(endpoint, "cci_get_opt", ret, 1);
if (!suppress)
printf("Opened %s\n", uri);
if (is_server)
do_server();
else
do_client();
/* clean up */
ret = cci_destroy_endpoint(endpoint);
check_return(endpoint, "cci_destroy_endpoint", ret, 1);
if (buffer)
free(buffer);
free(transport);
free(uri);
ret = cci_finalize();
check_return(NULL, "cci_finalize", ret, 1);
#ifdef USE_MPI
MPI_Barrier();
MPI_Finalize();
#endif
return 0;
}
static void do_server(void)
{
int ret;
while (!ready) {
cci_event_t *event;
if (blocking) {
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
ret = select(nfds, &rfds, NULL, NULL, NULL);
if (!ret)
return;
}
ret = cci_get_event(endpoint, &event);
if (ret == CCI_SUCCESS) {
switch (event->type) {
case CCI_EVENT_CONNECT_REQUEST:
if (accept) {
opts =
*((options_t *) event->request.
data_ptr);
ret = cci_accept(event, NULL);
check_return(endpoint, "cci_accept", ret, 1);
} else {
ret = cci_reject(event);
check_return(endpoint, "cci_reject", ret, 1);
}
break;
case CCI_EVENT_ACCEPT:
{
int len;
ready = 1;
connection = event->accept.connection;
if (opts.method == MSGS)
len = connection->max_send_size;
else
len = opts.max_rma_size;
ret =
posix_memalign((void **)&buffer,
4096, len);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 'a', len);
if (opts.method != MSGS) {
ret =
cci_rma_register(endpoint,
buffer,
opts.
max_rma_size,
opts.method == RMA_WRITE ? CCI_FLAG_WRITE : CCI_FLAG_READ,
&server_rma_handle);
check_return(endpoint, "cci_rma_register",
ret, 1);
memcpy(&opts.rma_handle,
server_rma_handle,
sizeof(*server_rma_handle));
}
ret =
cci_send(connection, &opts,
sizeof(opts), NULL, 0);
check_return(endpoint, "cci_send", ret, 1);
break;
}
default:
fprintf(stderr,
"%s: ignoring unexpected event %d\n",
__func__, event->type);
break;
}
ret = cci_return_event(event);
if (ret)
fprintf(stderr, "cci_return_event() failed with %s\n",
cci_strerror(endpoint, ret));
}
}
while (!done)
poll_events();
if (opts.method != MSGS) {
ret = cci_rma_deregister(endpoint, server_rma_handle);
check_return(endpoint, "cci_rma_deregister", ret, 1);
}
printf("server done\n");
sleep(1);
return;
}
