END_TEST START_TEST (create_endpoint_loop) { uint32_t initFlags = 0; uint32_t capabilities = 0; uint32_t status = 0; cci_device_t const ** const devices = NULL; /* available device structure */ cci_device_t const ** d = NULL; cci_endpoint_t* endpointP = NULL; /* pointer to endpoint structure */ int32_t deviceFlags = 0; /* not yet implemented */ cci_os_handle_t fd; /* endpoint handle */ uint32_t i; /* Initialize cci library */ status = cci_init(CCI_ABI_VERSION, initFlags, &capabilities); fail_unless(status == CCI_SUCCESS, "cci_init() failed with status %s", cci_strerror(NULL, status)); /* get a list of the available devices */ status = cci_get_devices((cci_device_t * const **) &devices); fail_unless(status == CCI_SUCCESS, "cci_get_devices() failed with status %s", cci_strerror(NULL, status)); for(i=0; i<10; ++i) { for(d = devices; *d != NULL; ++d) { status = cci_create_endpoint((cci_device_t*) *d, deviceFlags, &endpointP, &fd); fail_unless(status == CCI_SUCCESS, "cci_create_endpoint() failed with status %s", cci_strerror(NULL, status)); status = cci_destroy_endpoint(endpointP); fail_unless(status == CCI_SUCCESS, "cci_destroy_endpoint() failed with status %s", cci_strerror(NULL, status)); } } }
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 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; }
int main(int argc, char *argv[]) { int ret, c; uint32_t caps = 0; cci_os_handle_t *os_handle = NULL; char *uri = NULL; pid_t pid = 0; pid = getpid(); srandom(pid); memset(&msg, 0, sizeof(msg)); name = argv[0]; while ((c = getopt(argc, argv, "h:si:c:wrl:o:O:R:BI")) != -1) { switch (c) { case 'h': server_uri = strdup(optarg); is_client = 1; break; case 's': is_server = 1; break; case 'i': iters = strtoul(optarg, NULL, 0); break; case 'c': if (strncasecmp("ru", optarg, 2) == 0) attr = CCI_CONN_ATTR_RU; else if (strncasecmp("ro", optarg, 2) == 0) attr = CCI_CONN_ATTR_RO; else print_usage(); printf("Using %s connection\n", attr == CCI_CONN_ATTR_RU ? "RU" : "RO"); break; case 'w': opts.method = RMA_WRITE; break; case 'r': opts.method = RMA_READ; break; case 'l': length = strtoul(optarg, NULL, 0); break; case 'R': opts.reg_len = strtoul(optarg, NULL, 0); break; case 'o': local_offset = strtoul(optarg, NULL, 0); break; case 'O': remote_offset = strtoul(optarg, NULL, 0); break; case 'B': blocking = 1; os_handle = &fd; break; case 'I': ignore_os_handle = 1; os_handle = &fd; break; default: print_usage(); } } if (!is_server && !server_uri) { fprintf(stderr, "Must select -h or -s\n"); print_usage(); } if (is_server && is_client) { fprintf(stderr, "Must select -h or -s, not both\n"); print_usage(); } if (blocking && ignore_os_handle) { fprintf(stderr, "-B and -I are not compatible.\n"); fprintf(stderr, "-B will block using select() using the OS handle.\n"); fprintf(stderr, "-I will obtain the OS handle, but not use it to wait.\n"); print_usage(); } if (!opts.method) opts.method = RMA_WRITE; if (!opts.reg_len) { if (!length) { opts.reg_len = RMA_REG_LEN; } else { opts.reg_len = length; } } if (!length) { if (!opts.reg_len) length = RMA_REG_LEN; else length = opts.reg_len; } if (opts.reg_len == length) { if (local_offset || remote_offset) { fprintf(stderr, "*** RMA registration length == RMA length " "and an offset was requested. ***\n" "*** This should cause an error. ***\n"); } } if (is_client) fprintf(stderr, "Testing with local_offset %"PRIu64" " "remote_offset %"PRIu64" " "reg_len %"PRIu64" length %"PRIu64"\n", local_offset, remote_offset, opts.reg_len, length); ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, os_handle); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } printf("Opened %s\n", uri); if (blocking) { nfds = fd + 1; FD_ZERO(&rfds); FD_SET(fd, &rfds); } if (is_server) do_server(); else do_client(); /* clean up */ ret = cci_destroy_endpoint(endpoint); if (ret) { fprintf(stderr, "cci_destroy_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } free(buffer); free(uri); free(server_uri); ret = cci_finalize(); if (ret) { fprintf(stderr, "cci_finalize() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } return 0; }
int main(int argc, char *argv[]) { int ret, c; uint32_t caps = 0; cci_os_handle_t *os_handle = NULL; char *uri = NULL; name = argv[0]; while ((c = getopt(argc, argv, "h:sRc:nwrm:Ci:W:bo")) != -1) { switch (c) { case 'h': server_uri = strdup(optarg); break; case 's': is_server = 1; break; case 'R': accept = 0; break; case 'i': iters = strtoul(optarg, NULL, 0); break; case 'W': warmup = strtoul(optarg, NULL, 0); break; case 'c': if (strncasecmp("ru", optarg, 2) == 0) attr = CCI_CONN_ATTR_RU; else if (strncasecmp("ro", optarg, 2) == 0) attr = CCI_CONN_ATTR_RO; else if (strncasecmp("uu", optarg, 2) == 0) attr = CCI_CONN_ATTR_UU; else print_usage(); printf("Using %s connection\n", attr == CCI_CONN_ATTR_UU ? "UU" : attr == CCI_CONN_ATTR_RU ? "RU" : "RO"); break; case 'n': opts.flags = CCI_FLAG_NO_COPY; break; case 'w': opts.method = RMA_WRITE; break; case 'r': opts.method = RMA_READ; break; case 'm': opts.max_rma_size = strtoul(optarg, NULL, 0); break; case 'C': remote_completion = 1; break; case 'b': blocking = 1; os_handle = &fd; break; case 'o': ignore_os_handle = 1; os_handle = &fd; break; default: print_usage(); } } if (!is_server && !server_uri) { fprintf(stderr, "Must select -h or -s\n"); print_usage(); } if (blocking && ignore_os_handle) { fprintf(stderr, "-b and -o are not compatible.\n"); fprintf(stderr, "-b will block using select() using the OS handle.\n"); fprintf(stderr, "-o will obtain the OS handle, but not use it to wait.\n"); print_usage(); } if (attr == CCI_CONN_ATTR_UU) { if (opts.method != MSGS) { fprintf(stderr, "RMA %s not allowed with UU connections\n", opts.method == RMA_WRITE ? "WRITE" : "READ"); print_usage(); } if (opts.max_rma_size) { printf("ignoring max_rma_size (-m) with MSGs\n"); opts.max_rma_size = 0; } } else { /* RO or RU */ if (opts.flags == CCI_FLAG_NO_COPY) { printf("Ignoring CCI_FLAG_NO_COPY (-n) with RMA %s\n", opts.method == RMA_WRITE ? "WRITE" : "READ"); opts.flags &= ~(CCI_FLAG_NO_COPY); } if (!opts.max_rma_size) opts.max_rma_size = MAX_RMA_SIZE; } ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, os_handle); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } printf("Opened %s\n", uri); if (blocking) { nfds = fd + 1; FD_ZERO(&rfds); FD_SET(fd, &rfds); } if (is_server) do_server(); else do_client(); /* clean up */ ret = cci_destroy_endpoint(endpoint); if (ret) { fprintf(stderr, "cci_destroy_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } if (buffer) free(buffer); free(uri); free(server_uri); ret = cci_finalize(); if (ret) { fprintf(stderr, "cci_finalize() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } return 0; }
int main(int argc, char *argv[]) { cci_os_handle_t *fd = NULL; //endpoint 생성시, process를 block하는데 사용 cci_endpoint_t *endpoint = NULL; cci_connection_t *connection = NULL; int ret, c, ft_start = 0 , done = 0, i = 0, connect = 0; pthread_t send; uint32_t caps = 0;//?? char *server_uri = NULL; char id[16]=""; t_data thread_data; while ((c = getopt(argc, argv, "h:c:b")) != -1) { //client 실행시 option check switch (c) { case 'h': server_uri = strdup(optarg);//-h에 대한 인자를 가리키는 optarg 포인터가 생김 http://weed2758.tistory.com/entry/Linux-C-getopt-%ED%95%A8%EC%88%98 break; case 'c': if (strncasecmp ("ru", optarg, 2) == 0) attr = CCI_CONN_ATTR_RU; else if (strncasecmp ("ro", optarg, 2) == 0) attr = CCI_CONN_ATTR_RO; else if (strncasecmp ("uu", optarg, 2) == 0) attr = CCI_CONN_ATTR_UU; break; case 'b': flags |= CCI_FLAG_BLOCKING; break; default: fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n", argv[0]); fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) " "set by client; RO by default\n"); exit(EXIT_FAILURE); } } if (!server_uri) { fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n", argv[0]); fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) " "set by client; RO by default\n"); exit(EXIT_FAILURE); } ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, fd); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } if (ret) { fprintf(stderr, "cci_set_opt() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } /* initiate connect */ ret = cci_connect(endpoint, server_uri, "Connect request", 15, attr, CONNECT_CONTEXT, 0, NULL); if (ret) { fprintf(stderr, "cci_connect() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } while (!done) poll_events(endpoint, &connection, &done, id); if (!connection) exit(0); done = 0; thread_data.connection=connection; thread_data.flag=flags; thread_data.id=id; pthread_create(&send,NULL,send_msg,&thread_data); while(!done) poll_events(endpoint, &connection, &done, id); pthread_join(send,NULL); /* clean up */ ret = cci_destroy_endpoint(endpoint); if (ret) { fprintf(stderr, "cci_destroy_endpoint() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } ret = cci_finalize(); if (ret) { fprintf(stderr, "cci_finalize() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } return 0; }
int main (int argc, char *argv[]) { int ret, c; uint32_t caps = 0; char *ctl_uri = NULL; name = argv[0]; while ((c = getopt (argc, argv, "h:s")) != -1) { switch (c) { case 'h': server_uri = strdup (optarg); break; case 's': is_server = 1; break; default: print_usage (); } } ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* Create the endpoint for the control connection */ ret = cci_create_endpoint(NULL, 0, &ctl_ep, NULL); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(ctl_ep, CCI_OPT_ENDPT_URI, &ctl_uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } printf("Opened control connection %s\n", ctl_uri); if (is_server) do_server (); else do_client (); ret = cci_destroy_endpoint (ctl_ep); if (ret) { fprintf (stderr, "cci_destroy_endpoint() failed with %s\n", cci_strerror (NULL, ret)); exit (EXIT_FAILURE); } free (server_uri); ret = cci_finalize (); if (ret) { fprintf (stderr, "cci_finalize() failed with %s\n", cci_strerror (NULL, ret)); exit (EXIT_FAILURE); } return 0; }
int main(int argc, char *argv[]) { int ret, done = 0; uint32_t caps = 0; char *uri = NULL; cci_endpoint_t *endpoint = NULL; cci_os_handle_t *ep_fd = NULL; cci_connection_t *connection = NULL; ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, ep_fd); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } printf("Opened %s\n", uri); while (!done) { int accept = 1; cci_event_t *event; ret = cci_get_event(endpoint, &event); if (ret != 0) { if (ret != CCI_EAGAIN) fprintf(stderr, "cci_get_event() returned %s\n", cci_strerror(endpoint, ret)); continue; } switch (event->type) { case CCI_EVENT_RECV:{ char buf[8192]; char *data = "data:"; int offset = 0; int len = event->recv.len; assert(event->recv.connection == connection); assert(event->recv.connection->context == ACCEPT_CONTEXT); if (len == 3) { done = 1; continue; } memset(buf, 0, 8192); offset = strlen(data); memcpy(buf, data, offset); memcpy(buf + offset, event->recv.ptr, len); offset += len; fprintf(stderr, "recv'd \"%s\"\n", buf); ret = cci_send(connection, buf, offset, SEND_CONTEXT, 0); if (ret) fprintf(stderr, "send returned %s\n", cci_strerror(endpoint, ret)); break; } case CCI_EVENT_SEND: fprintf(stderr, "completed send\n"); assert(event->send.context == SEND_CONTEXT); assert(event->send.connection == connection); assert(event->send.connection->context == ACCEPT_CONTEXT); break; case CCI_EVENT_CONNECT_REQUEST: /* inspect conn_req_t and decide to accept or reject */ if (accept) { /* associate this connect request with this endpoint */ cci_accept(event, ACCEPT_CONTEXT); } else { cci_reject(event); } break; case CCI_EVENT_ACCEPT: fprintf(stderr, "completed accept\n"); assert(event->accept.connection != NULL); assert(event->accept.connection->context == ACCEPT_CONTEXT); connection = event->accept.connection; break; default: printf("event type %d\n", event->type); break; } cci_return_event(event); } /* clean up */ cci_destroy_endpoint(endpoint); cci_finalize(); free(uri); return 0; }
int main(int argc, char *argv[]) { int ret, number_of_connections=0; int client_end[MAX_CONNECTION_SIZE]={0,}; uint32_t caps = 0; char *uri = NULL; long file_size[MAX_CONNECTION_SIZE]={0,}; cci_endpoint_t *endpoint = NULL; cci_os_handle_t *ep_fd = NULL; cci_connection_t *connection[MAX_CONNECTION_SIZE] = {NULL,}; ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, ep_fd); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } printf("Opened %s\n", uri); while (1) { int accept = 1; cci_event_t *event; ret = cci_get_event(endpoint, &event); if (ret != 0) { if (ret != CCI_EAGAIN) fprintf(stderr, "cci_get_event() returned %s\n", cci_strerror(endpoint, ret)); continue; } switch (event->type) { case CCI_EVENT_RECV:{ char buf[MAX_BUFFER_SIZE]; char *number, *data; char exit_msg[32]; long read_size=0; int len = event->recv.len; int i=0, j=0; int id; memset(buf, 0, MAX_BUFFER_SIZE); memcpy(buf, event->recv.ptr, len); if(strncasecmp((char*)event->recv.ptr,"client", 6)==0){ /* 문자인 경우 */ fprintf(stderr, "%s", buf); strtok(buf," :"); /* 필요한 정보 파싱 (누구한테, 첫번째 문자)*/ number=strtok(NULL," :"); data=strtok(NULL," :"); id=atoi(number); //누구한테서 왔는지 memcpy(buf, event->recv.ptr, len); if(event->recv.connection==connection[id-1]){ if(strncasecmp(data,"bye\n", 4)==0){ //종료를 원할 경우 fprintf(stderr, "Client%d want to termainate this program.\n", id); client_end[id-1]=1; }else if(strncasecmp(data,"file\n", 5)==0) //file 전송을 원할 경우 fprintf(stderr, "Client %d send a file...\n", id); for(j=0; j<number_of_connections; j++){ if(j !=id-1 && !client_end[j]) //받는놈은 종료되지 않은놈이고 보내는놈이 아님 ret = cci_send(connection[j], buf, len, SEND_CONTEXT, 0); //보냄 if(client_end[id-1]){ //보내는놈이 종료를 원한 경우 sprintf(exit_msg,"client%d exits..\n", id); ret = cci_send(connection[j], exit_msg, strlen(exit_msg), SEND_CONTEXT, 0); //종료메세지 보냄 } } //end for j } }else{ /* 파일인 경우 */ for(i=0; i<number_of_connections; i++){ //어떤 connection에서 왔는지 check if(event->recv.connection == connection[i]){ if(strncasecmp((char*)event->recv.ptr,"file send completed\0", 20)==0){ //file 전송종료신호면 그만 fprintf(stderr,"%s. file size is %ldbytes.\n",(char*)event->recv.ptr, file_size[i]); memcpy(buf,event->recv.ptr, len); //종료신호 고대로 클라에게 read_size=len; file_size[i]=0; }else{ read_size=event->recv.len; //읽은 크기 file_size[i]+=read_size; //file size check fprintf(stderr, "%ld\n", file_size[i]); memcpy(buf, event->recv.ptr, read_size); //읽은거 buf에 써주기 }//end file trasport for(j=0; j<number_of_connections; j++){ /* broadcast */ if(j !=i && !client_end[j]){ ret = cci_send(connection[j], buf, read_size, SEND_CONTEXT, 0); if(ret) fprintf(stderr, "file send failed!\n"); } }//end for j break; }//end if }//end for i } break; }//end recv case case CCI_EVENT_SEND: assert(event->send.context == SEND_CONTEXT); assert(event->send.connection->context == ACCEPT_CONTEXT); fprintf(stderr, "completed send\n"); break; case CCI_EVENT_CONNECT_REQUEST: if (accept) { cci_accept(event, ACCEPT_CONTEXT); }else { cci_reject(event); } break; case CCI_EVENT_ACCEPT:{ char number[MAX_CONNECTION_SIZE]; assert(event->accept.connection != NULL); assert(event->accept.connection->context == ACCEPT_CONTEXT); connection[number_of_connections] = event->accept.connection; fprintf(stderr, "completed accept\n"); sprintf(number,"%d",number_of_connections+1); ret = cci_send(connection[number_of_connections], number, strlen(number), SEND_CONTEXT, 0); //몇번째 클라이언트 인지 알려줌 number_of_connections++; break; } default: printf("event type %d\n", event->type); break; } //end switch cci_return_event(event); } /* clean up */ cci_destroy_endpoint(endpoint); cci_finalize(); free(uri); return 0; }
int main(int argc, char *argv[]) { int done = 0, ret, i = 0, c; uint32_t caps = 0; char *server_uri = NULL; /* ip://1.2.3.4 */ char *uri = NULL; cci_os_handle_t fd; cci_endpoint_t *endpoint = NULL; cci_connection_t *connection = NULL; uint32_t timeout_us = 30 * 1000000; /* microseconds */ proc_name = argv[0]; while ((c = getopt(argc, argv, "h:")) != -1) { switch (c) { case 'h': server_uri = strdup(optarg); break; default: usage(); } } /* init */ ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() returned %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, &fd); if (ret) { fprintf(stderr, "cci_create_endpoint() returned %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } printf("Opened %s\n", uri); /* set endpoint tx timeout */ cci_set_opt(endpoint, CCI_OPT_ENDPT_SEND_TIMEOUT, &timeout_us); if (ret) { fprintf(stderr, "cci_set_opt() returned %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } /* initiate connect */ ret = cci_connect(endpoint, server_uri, "Hello World!", 12, CCI_CONN_ATTR_UU, NULL, 0, NULL); if (ret) { fprintf(stderr, "cci_connect() returned %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } /* poll for connect completion */ while (!done) poll_events(endpoint, &connection, &done); if (!connection) { fprintf(stderr, "no connection\n"); exit(EXIT_FAILURE); } /* begin communication with server */ char *data; int max = connection->max_send_size; data = (char*)malloc(max); memset(data, 1, sizeof(data)); int len = 128; int repeat = 1000; while (len <= max) { s = cci_get_time(); for (i = 0; i < repeat; i++) { /* ret = cci_send(connection, data, (uint32_t) strlen(data), */ /* (void *)(uintptr_t) i, 0); */ ret = cci_send(connection, data, len, (void *)(uintptr_t) i, 0); if (ret > 0) { fprintf(stderr, "send %d returned %s\n", i, cci_strerror(endpoint, ret)); exit(1); } done = 0; while (!done) poll_events(endpoint, &connection, &done); } e = cci_get_time(); fprintf(stderr, "%d %f %f\n", len, (e - s) / repeat, (len / (e - s)) * repeat); len = len << 1; sleep(1); } /* clean up */ ret = cci_disconnect(connection); if (ret) { fprintf(stderr, "cci_disconnect() returned %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } ret = cci_destroy_endpoint(endpoint); if (ret) { fprintf(stderr, "cci_destroy_endpoint() returned %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* add cci_finalize() here */ return 0; }
int main(int argc, char *argv[]) { int ret; uint32_t caps = 0; char *uri = NULL; cci_endpoint_t *endpoint = NULL; cci_os_handle_t ep_fd; cci_connection_t *connection = NULL; /* init */ ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, &ep_fd); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } printf("Opened %s\n", uri); while (1) { cci_event_t *event; ret = cci_get_event(endpoint, &event); if (ret != CCI_SUCCESS) { if (ret != CCI_EAGAIN) { fprintf(stderr, "cci_get_event() returned %s", cci_strerror(endpoint, ret)); } continue; } /* fprintf(stderr, "ret: %d, event: %d (RECV:%d, SEND:%d, CONNECT_REQ:%d, ACCEPT:%d)\n", */ /* ret, event->type, CCI_EVENT_RECV, CCI_EVENT_SEND, CCI_EVENT_CONNECT_REQUEST, */ /* CCI_EVENT_ACCEPT); */ fprintf(stderr, "Event: %s, ret:%d len: %lu\n", cci_event_type_str(event->type), ret, event->recv.len); switch (event->type) { case CCI_EVENT_RECV: { // fprintf(stderr, "=====: %p %p %d\n", buffer, event->recv.ptr, event->recv.len); // memcpy(buffer, // event->recv.ptr, event->recv.len); // fprintf(stderr, "=====\n"); // buffer[event->recv.len] = 0; // printf("recv'd \n"); /* echo the message to the client */ ret = cci_send(connection, event->recv.ptr, event->recv.len, NULL, 0); if (ret != CCI_SUCCESS) fprintf(stderr, "send returned %s\n", cci_strerror(endpoint, ret)); break; } case CCI_EVENT_SEND: // printf("completed send\n"); break; case CCI_EVENT_CONNECT_REQUEST: { int accept = 1; if (accept) { ret = cci_accept(event, NULL); if (ret != CCI_SUCCESS) { fprintf(stderr, "cci_accept() returned %s", cci_strerror(endpoint, ret)); } } else { cci_reject(event); } } break; case CCI_EVENT_ACCEPT: connection = event->accept.connection; if (!buffer) { buffer = calloc(1, connection->max_send_size + 1); fprintf(stderr, "allocated buffer: %p , size %d", buffer, connection->max_send_size + 1); /* check for buffer ... */ } else { fprintf(stderr, "Not allocated\n"); } break; default: fprintf(stderr, "unexpected event %d", event->type); break; } cci_return_event(event); } /* clean up */ cci_destroy_endpoint(endpoint); /* add cci_finalize() here */ return 0; }
int main(int argc, char *argv[]) { int done = 0, ret, i = 0, c; uint32_t caps = 0; char *server_uri = NULL; cci_os_handle_t *fd = NULL; cci_endpoint_t *endpoint = NULL; cci_connection_t *connection = NULL; uint32_t timeout = 30 * 1000000; while ((c = getopt(argc, argv, "h:c:b")) != -1) { switch (c) { case 'h': server_uri = strdup(optarg); break; case 'c': if (strncasecmp ("ru", optarg, 2) == 0) attr = CCI_CONN_ATTR_RU; else if (strncasecmp ("ro", optarg, 2) == 0) attr = CCI_CONN_ATTR_RO; else if (strncasecmp ("uu", optarg, 2) == 0) attr = CCI_CONN_ATTR_UU; break; case 'b': flags |= CCI_FLAG_BLOCKING; break; default: fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n", argv[0]); fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) " "set by client; RO by default\n"); exit(EXIT_FAILURE); } } if (!server_uri) { fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n", argv[0]); fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) " "set by client; RO by default\n"); exit(EXIT_FAILURE); } ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, fd); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* set conn tx timeout */ cci_set_opt(endpoint, CCI_OPT_ENDPT_SEND_TIMEOUT, &timeout); if (ret) { fprintf(stderr, "cci_set_opt() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } /* initiate connect */ ret = cci_connect(endpoint, server_uri, "Hello World!", 12, attr, CONNECT_CONTEXT, 0, NULL); if (ret) { fprintf(stderr, "cci_connect() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } /* poll for connect completion */ while (!done) poll_events(endpoint, &connection, &done); if (!connection) exit(0); done = 0; /* begin communication with server */ for (i = 0; i < iters; i++) { char data[128]; memset(data, 0, sizeof(data)); sprintf(data, "%4d", i); sprintf(data + 4, "Hello World!"); ret = cci_send(connection, data, (uint32_t) strlen(data) + 4, (void *)(uintptr_t) i, flags); if (ret) fprintf(stderr, "send %d failed with %s\n", i, cci_strerror(endpoint, ret)); if (flags & CCI_FLAG_BLOCKING) fprintf(stderr, "send %d completed with %d\n", i, ret); } if (flags == CCI_FLAG_BLOCKING) send_done = iters; while (!done) poll_events(endpoint, &connection, &done); ret = cci_send(connection, "bye", 3, (void *)(uintptr_t) iters, flags); if (ret) fprintf(stderr, "sending \"bye\" failed with %s\n", cci_strerror(endpoint, ret)); if (flags & CCI_FLAG_BLOCKING) done = 2; while (done != 2) poll_events(endpoint, &connection, &done); /* clean up */ ret = cci_destroy_endpoint(endpoint); if (ret) { fprintf(stderr, "cci_destroy_endpoint() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } ret = cci_finalize(); if (ret) { fprintf(stderr, "cci_finalize() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } return 0; }
void server() { int ret, context, num_request = 0, num_accept = 0; uint32_t caps = 0; char *uri = NULL; cci_endpoint_t *endpoint = NULL; cci_os_handle_t *ep_fd = NULL; cci_connection_t *connection = NULL; ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, ep_fd); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } ret = cci_get_opt(endpoint, CCI_OPT_ENDPT_URI, &uri); if (ret) { fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } printf("Opened %s\n", uri); fflush(stdout); while (num_request < 3 || num_accept < 1) { cci_event_t *event; ret = cci_get_event(endpoint, &event); if (ret != 0) { if (ret != CCI_EAGAIN) fprintf(stderr, "cci_get_event() returned %s\n", cci_strerror(endpoint, ret)); continue; } switch (event->type) { case CCI_EVENT_CONNECT_REQUEST: fprintf(stderr, "connect request\n"); num_request++; /* accept the first, reject the second, let the third timeout */ if (num_request == 1) { context = 123; cci_accept(event, (int *) &context); } else if (num_request == 2 && 0) { /* XXX: cci_reject segfaults */ cci_reject(event); } break; case CCI_EVENT_ACCEPT: fprintf(stderr, "completed accept\n"); connection = event->accept.connection; context = *(int *) event->accept.context; printf("CCI_EVENT_ACCEPT: %d\n", context); num_accept++; break; default: fprintf(stderr, "ignoring event type %d\n", event->type); } cci_return_event(event); } printf("Pausing while client times out...\n"); sleep(5); printf("test passed\n"); fflush(stdout); server_cleanup: ret = cci_destroy_endpoint(endpoint); if (ret) { fprintf(stderr, "cci_destroy_endpoint() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } ret = cci_finalize(); if (ret) { fprintf(stderr, "cci_finalize() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } free(uri); }
void client(char *server_uri) { int num_connect = 0, ret, i = 0, c; uint32_t caps = 0; cci_os_handle_t *fd = NULL; cci_endpoint_t *endpoint = NULL; cci_connection_t *connection = NULL; uint32_t timeout = 10 * 1000000; int context[3] = {0, 1, 2}; struct timeval wait; ret = cci_init(CCI_ABI_VERSION, 0, &caps); if (ret) { fprintf(stderr, "cci_init() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* create an endpoint */ ret = cci_create_endpoint(NULL, 0, &endpoint, fd); if (ret) { fprintf(stderr, "cci_create_endpoint() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } /* set conn tx timeout */ cci_set_opt(endpoint, CCI_OPT_ENDPT_SEND_TIMEOUT, &timeout); if (ret) { fprintf(stderr, "cci_set_opt() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } ret = cci_connect(endpoint, server_uri, "Happy", 5, CCI_CONN_ATTR_UU, (int *) &context[0], 0, NULL); if (ret) { fprintf(stderr, "cci_connect(0) failed with %s\n", cci_strerror(endpoint, ret)); } ret = cci_connect(endpoint, server_uri, "New", 3, CCI_CONN_ATTR_UU, (int *) &context[1], 0, NULL); if (ret) { fprintf(stderr, "cci_connect(1) failed with %s\n", cci_strerror(endpoint, ret)); } wait.tv_sec = 2; wait.tv_usec = 0; ret = cci_connect(endpoint, server_uri, "Year", 4, CCI_CONN_ATTR_UU, (int *) &context[2], 0, &wait); if (ret) { fprintf(stderr, "cci_connect(2) failed with %s\n", cci_strerror(endpoint, ret)); } /* poll for connect completion */ //while (num_connect < 3) while (num_connect < 1) /* connect timeouts are not registering */ poll_events(endpoint, &connection, &num_connect); printf("test passed\n"); fflush(stdout); /* server has to close first to avoid hang */ sleep(5); client_cleanup: ret = cci_destroy_endpoint(endpoint); if (ret) { fprintf(stderr, "cci_destroy_endpoint() failed with %s\n", cci_strerror(endpoint, ret)); exit(EXIT_FAILURE); } ret = cci_finalize(); if (ret) { fprintf(stderr, "cci_finalize() failed with %s\n", cci_strerror(NULL, ret)); exit(EXIT_FAILURE); } }